@types/npm

  • Version 7.19.3
  • Published
  • 18.9 kB
  • 1 dependency
  • MIT license

Install

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

Overview

TypeScript definitions for npm

Index

Variables

Interfaces

Variables

variable npm

var npm: npm.Static;

    Interfaces

    interface CommandCallback

    interface CommandCallback {}

      call signature

      (err?: Error, result?: any, result2?: any, result3?: any, result4?: any): void;

        interface CommandFunction

        interface CommandFunction {}

          call signature

          (args: string[], callback: CommandCallback): void;

            interface Commands

            interface Commands {}

              property "add-user"

              'add-user': CommandFunction;

                property "dist-tag"

                'dist-tag': CommandFunction;
                • https://docs.npmjs.com/cli/v7/commands/npm-dist-tag

                property "dist-tags"

                'dist-tags': CommandFunction;
                • Alias for dist-tag

                  https://docs.npmjs.com/cli/v7/commands/npm-dist-tag

                property "find-dupes"

                'find-dupes': CommandFunction;

                  property "help-search"

                  'help-search': CommandFunction;

                    property "install-ci-test"

                    'install-ci-test': CommandFunction;
                    • https://docs.npmjs.com/cli/v7/commands/npm-install-ci-test

                    property "install-test"

                    'install-test': CommandFunction;
                    • https://docs.npmjs.com/cli/v7/commands/npm-install-test

                    property "run-script"

                    'run-script': CommandFunction;

                      property "set-script"

                      'set-script': CommandFunction;
                      • https://docs.npmjs.com/cli/v7/commands/npm-set-script

                      property access

                      access: CommandFunction;
                      • https://docs.npmjs.com/cli/v7/commands/npm-access

                      property adduser

                      adduser: CommandFunction;

                        property apihelp

                        apihelp: CommandFunction;

                          property audit

                          audit: CommandFunction;
                          • https://docs.npmjs.com/cli/v7/commands/npm-audit

                          property author

                          author: CommandFunction;

                            property bin

                            bin: CommandFunction;

                              property bugs

                              bugs: CommandFunction;

                                property build

                                build: CommandFunction;

                                  property c

                                  c: CommandFunction;

                                    property cache

                                    cache: CommandFunction;

                                      property ci

                                      ci: CommandFunction;
                                      • https://docs.npmjs.com/cli/v7/commands/npm-ci

                                      property cit

                                      cit: CommandFunction;
                                      • Alias for install-ci-test

                                        https://docs.npmjs.com/cli/v7/commands/npm-install-ci-test

                                      property completion

                                      completion: CommandFunction;

                                        property config

                                        config: CommandFunction;

                                          property ddp

                                          ddp: CommandFunction;

                                            property dedupe

                                            dedupe: CommandFunction;

                                              property deprecate

                                              deprecate: CommandFunction;

                                                property diff

                                                diff: CommandFunction;
                                                • https://docs.npmjs.com/cli/v7/commands/npm-diff

                                                property docs

                                                docs: CommandFunction;

                                                  property doctor

                                                  doctor: CommandFunction;
                                                  • https://docs.npmjs.com/cli/v7/commands/npm-doctor

                                                  property edit

                                                  edit: CommandFunction;

                                                    property exec

                                                    exec: CommandFunction;
                                                    • https://docs.npmjs.com/cli/v7/commands/npm-exec

                                                    property explain

                                                    explain: CommandFunction;
                                                    • https://docs.npmjs.com/cli/v7/commands/npm-explain

                                                    property explore

                                                    explore: CommandFunction;

                                                      property faq

                                                      faq: CommandFunction;

                                                        property find

                                                        find: CommandFunction;

                                                          property fund

                                                          fund: CommandFunction;
                                                          • https://docs.npmjs.com/cli/v7/commands/npm-fund

                                                          property get

                                                          get: CommandFunction;

                                                            property help

                                                            help: CommandFunction;

                                                              property home

                                                              home: CommandFunction;

                                                                property hook

                                                                hook: CommandFunction;
                                                                • https://docs.npmjs.com/cli/v7/commands/npm-hook

                                                                property i

                                                                i: CommandFunction;

                                                                  property init

                                                                  init: CommandFunction;

                                                                    property install

                                                                    install: CommandFunction;

                                                                      property isntall

                                                                      isntall: CommandFunction;

                                                                        property issues

                                                                        issues: CommandFunction;

                                                                          property it

                                                                          it: CommandFunction;
                                                                          • Alias for install-test

                                                                            https://docs.npmjs.com/cli/v7/commands/npm-install-test

                                                                          property la

                                                                          la: CommandFunction;
                                                                            link: CommandFunction;

                                                                              property list

                                                                              list: CommandFunction;

                                                                                property ll

                                                                                ll: CommandFunction;

                                                                                  property logout

                                                                                  logout: CommandFunction;
                                                                                  • https://docs.npmjs.com/cli/v7/commands/npm-logout

                                                                                  property long

                                                                                  long: CommandFunction;

                                                                                    property ls

                                                                                    ls: CommandFunction;

                                                                                      property org

                                                                                      org: CommandFunction;
                                                                                      • https://docs.npmjs.com/cli/v7/commands/npm-org

                                                                                      property outdated

                                                                                      outdated: CommandFunction;

                                                                                        property owner

                                                                                        owner: CommandFunction;

                                                                                          property pack

                                                                                          pack: CommandFunction;

                                                                                            property ping

                                                                                            ping: CommandFunction;
                                                                                            • https://docs.npmjs.com/cli/v7/commands/npm-ping

                                                                                            property prefix

                                                                                            prefix: CommandFunction;

                                                                                              property profile

                                                                                              profile: CommandFunction;
                                                                                              • https://docs.npmjs.com/cli/v7/commands/npm-profile

                                                                                              property prune

                                                                                              prune: CommandFunction;

                                                                                                property publish

                                                                                                publish: CommandFunction;

                                                                                                  property r

                                                                                                  r: CommandFunction;

                                                                                                    property rb

                                                                                                    rb: CommandFunction;

                                                                                                      property rebuild

                                                                                                      rebuild: CommandFunction;

                                                                                                        property remove

                                                                                                        remove: CommandFunction;

                                                                                                          property repo

                                                                                                          repo: CommandFunction;

                                                                                                            property restart

                                                                                                            restart: CommandFunction;

                                                                                                              property rm

                                                                                                              rm: CommandFunction;

                                                                                                                property root

                                                                                                                root: CommandFunction;

                                                                                                                  property s

                                                                                                                  s: CommandFunction;

                                                                                                                    property se

                                                                                                                    se: CommandFunction;

                                                                                                                      property search

                                                                                                                      search: CommandFunction;

                                                                                                                        property set

                                                                                                                        set: CommandFunction;

                                                                                                                          property shrinkwrap

                                                                                                                          shrinkwrap: CommandFunction;

                                                                                                                            property star

                                                                                                                            star: CommandFunction;

                                                                                                                              property stars

                                                                                                                              stars: CommandFunction;

                                                                                                                                property start

                                                                                                                                start: CommandFunction;

                                                                                                                                  property stop

                                                                                                                                  stop: CommandFunction;

                                                                                                                                    property submodule

                                                                                                                                    submodule: CommandFunction;

                                                                                                                                      property substack

                                                                                                                                      substack: CommandFunction;

                                                                                                                                        property t

                                                                                                                                        t: CommandFunction;

                                                                                                                                          property tag

                                                                                                                                          tag: CommandFunction;

                                                                                                                                            property team

                                                                                                                                            team: CommandFunction;
                                                                                                                                            • https://docs.npmjs.com/cli/v7/commands/npm-team

                                                                                                                                            property test

                                                                                                                                            test: CommandFunction;

                                                                                                                                              property token

                                                                                                                                              token: CommandFunction;
                                                                                                                                              • https://docs.npmjs.com/cli/v7/commands/npm-token

                                                                                                                                              property tst

                                                                                                                                              tst: CommandFunction;

                                                                                                                                                property un

                                                                                                                                                un: CommandFunction;

                                                                                                                                                  property unbuild

                                                                                                                                                  unbuild: CommandFunction;

                                                                                                                                                    property uninstall

                                                                                                                                                    uninstall: CommandFunction;
                                                                                                                                                      unlink: CommandFunction;

                                                                                                                                                        property unpublish

                                                                                                                                                        unpublish: CommandFunction;

                                                                                                                                                          property unstar

                                                                                                                                                          unstar: CommandFunction;

                                                                                                                                                            property up

                                                                                                                                                            up: CommandFunction;

                                                                                                                                                              property update

                                                                                                                                                              update: CommandFunction;

                                                                                                                                                                property version

                                                                                                                                                                version: CommandFunction;

                                                                                                                                                                  property visnup

                                                                                                                                                                  visnup: CommandFunction;

                                                                                                                                                                    property whoami

                                                                                                                                                                    whoami: CommandFunction;

                                                                                                                                                                      property why

                                                                                                                                                                      why: CommandFunction;
                                                                                                                                                                      • Alias for explain

                                                                                                                                                                        https://docs.npmjs.com/cli/v7/commands/npm-dist-tag

                                                                                                                                                                      property x

                                                                                                                                                                      x: CommandFunction;
                                                                                                                                                                      • Alias for exec

                                                                                                                                                                        https://docs.npmjs.com/cli/v7/commands/npm-exec

                                                                                                                                                                      property xmas

                                                                                                                                                                      xmas: CommandFunction;

                                                                                                                                                                        method info

                                                                                                                                                                        info: {
                                                                                                                                                                        (args: string[], callback: CommandCallback): void;
                                                                                                                                                                        (args: string[], silent: boolean, callback: CommandCallback): void;
                                                                                                                                                                        };

                                                                                                                                                                          method show

                                                                                                                                                                          show: {
                                                                                                                                                                          (args: string[], callback: CommandCallback): void;
                                                                                                                                                                          (args: string[], silent: boolean, callback: CommandCallback): void;
                                                                                                                                                                          };

                                                                                                                                                                            method v

                                                                                                                                                                            v: {
                                                                                                                                                                            (args: string[], callback: CommandCallback): void;
                                                                                                                                                                            (args: string[], silent: boolean, callback: CommandCallback): void;
                                                                                                                                                                            };

                                                                                                                                                                              method view

                                                                                                                                                                              view: {
                                                                                                                                                                              (args: string[], callback: CommandCallback): void;
                                                                                                                                                                              (args: string[], silent: boolean, callback: CommandCallback): void;
                                                                                                                                                                              };

                                                                                                                                                                                interface Config

                                                                                                                                                                                interface Config {}

                                                                                                                                                                                  property Conf

                                                                                                                                                                                  Conf: ConfigStatic;

                                                                                                                                                                                    property defs

                                                                                                                                                                                    defs: ConfigDefs;

                                                                                                                                                                                      property loaded

                                                                                                                                                                                      loaded: boolean;

                                                                                                                                                                                        property root

                                                                                                                                                                                        root?: Config | undefined;

                                                                                                                                                                                          property rootConf

                                                                                                                                                                                          rootConf: Config;

                                                                                                                                                                                            property sources

                                                                                                                                                                                            sources: Dictionary<ConfigSource>;

                                                                                                                                                                                              property usingBuiltin

                                                                                                                                                                                              usingBuiltin: boolean;

                                                                                                                                                                                                method add

                                                                                                                                                                                                add: (data: Object, marker: Object) => any;

                                                                                                                                                                                                  method addEnv

                                                                                                                                                                                                  addEnv: (env: Dictionary<string>) => any;

                                                                                                                                                                                                    method addFile

                                                                                                                                                                                                    addFile: (file: string, name: string) => Config;

                                                                                                                                                                                                      method findPrefix

                                                                                                                                                                                                      findPrefix: (prefix: string, cb: SimpleCallback<string>) => void;

                                                                                                                                                                                                        method get

                                                                                                                                                                                                        get: (setting: string) => any;

                                                                                                                                                                                                          method getCredentialsByURI

                                                                                                                                                                                                          getCredentialsByURI: (uri: string) => Credentials;

                                                                                                                                                                                                            method loadCAFile

                                                                                                                                                                                                            loadCAFile: (caFilePath: string, cb: ErrorCallback) => void;

                                                                                                                                                                                                              method loadExtras

                                                                                                                                                                                                              loadExtras: (cb: ErrorCallback) => void;

                                                                                                                                                                                                                method loadPrefix

                                                                                                                                                                                                                loadPrefix: (cb: ErrorCallback) => void;

                                                                                                                                                                                                                  method loadUid

                                                                                                                                                                                                                  loadUid: (cb: SimpleCallback<string>) => void;

                                                                                                                                                                                                                    method parse

                                                                                                                                                                                                                    parse: (content: string, file: string) => any;

                                                                                                                                                                                                                      method save

                                                                                                                                                                                                                      save: (where: string, cb: ErrorCallback) => Config;

                                                                                                                                                                                                                        method set

                                                                                                                                                                                                                        set: (setting: string, value: any) => void;

                                                                                                                                                                                                                          method setCredentialsByURI

                                                                                                                                                                                                                          setCredentialsByURI: (uri: string, cred: Credentials) => void;

                                                                                                                                                                                                                            method setUser

                                                                                                                                                                                                                            setUser: (cb: ErrorCallback) => void;

                                                                                                                                                                                                                              interface ConfigDefs

                                                                                                                                                                                                                              interface ConfigDefs {}

                                                                                                                                                                                                                                property defaults

                                                                                                                                                                                                                                defaults: ConfigOptions;

                                                                                                                                                                                                                                  property types

                                                                                                                                                                                                                                  types: ConfigTypes;

                                                                                                                                                                                                                                    interface ConfigOptions

                                                                                                                                                                                                                                    interface ConfigOptions {}

                                                                                                                                                                                                                                      property "always-auth"

                                                                                                                                                                                                                                      'always-auth'?: boolean | undefined;

                                                                                                                                                                                                                                        property "bin-links"

                                                                                                                                                                                                                                        'bin-links'?: boolean | undefined;

                                                                                                                                                                                                                                          property "cache-lock-retries"

                                                                                                                                                                                                                                          'cache-lock-retries'?: number | undefined;

                                                                                                                                                                                                                                            property "cache-lock-stale"

                                                                                                                                                                                                                                            'cache-lock-stale'?: number | undefined;

                                                                                                                                                                                                                                              property "cache-lock-wait"

                                                                                                                                                                                                                                              'cache-lock-wait'?: number | undefined;

                                                                                                                                                                                                                                                property "cache-max"

                                                                                                                                                                                                                                                'cache-max'?: number | undefined;

                                                                                                                                                                                                                                                  property "cache-min"

                                                                                                                                                                                                                                                  'cache-min'?: number | undefined;

                                                                                                                                                                                                                                                    property "engine-strict"

                                                                                                                                                                                                                                                    'engine-strict'?: boolean | undefined;

                                                                                                                                                                                                                                                      property "fetch-retries"

                                                                                                                                                                                                                                                      'fetch-retries'?: number | undefined;

                                                                                                                                                                                                                                                        property "fetch-retry-factor"

                                                                                                                                                                                                                                                        'fetch-retry-factor'?: number | undefined;

                                                                                                                                                                                                                                                          property "fetch-retry-maxtimeout"

                                                                                                                                                                                                                                                          'fetch-retry-maxtimeout'?: number | undefined;

                                                                                                                                                                                                                                                            property "fetch-retry-mintimeout"

                                                                                                                                                                                                                                                            'fetch-retry-mintimeout'?: number | undefined;

                                                                                                                                                                                                                                                              property "git-tag-version"

                                                                                                                                                                                                                                                              'git-tag-version'?: boolean | undefined;

                                                                                                                                                                                                                                                                property "https-proxy"

                                                                                                                                                                                                                                                                'https-proxy'?: string | undefined;

                                                                                                                                                                                                                                                                  property "ignore-scripts"

                                                                                                                                                                                                                                                                  'ignore-scripts'?: boolean | undefined;

                                                                                                                                                                                                                                                                    property "init-module"

                                                                                                                                                                                                                                                                    'init-module'?: string | undefined;

                                                                                                                                                                                                                                                                      property "init.author.email"

                                                                                                                                                                                                                                                                      'init.author.email'?: string | undefined;

                                                                                                                                                                                                                                                                        property "init.author.name"

                                                                                                                                                                                                                                                                        'init.author.name'?: string | undefined;

                                                                                                                                                                                                                                                                          property "init.author.url"

                                                                                                                                                                                                                                                                          'init.author.url'?: string | undefined;

                                                                                                                                                                                                                                                                            property "init.license"

                                                                                                                                                                                                                                                                            'init.license'?: string | undefined;

                                                                                                                                                                                                                                                                              property "init.version"

                                                                                                                                                                                                                                                                              'init.version'?: string | undefined;

                                                                                                                                                                                                                                                                                property "local-address"

                                                                                                                                                                                                                                                                                'local-address'?: string | undefined;

                                                                                                                                                                                                                                                                                  property "node-version"

                                                                                                                                                                                                                                                                                  'node-version'?: string | undefined;

                                                                                                                                                                                                                                                                                    property "onload-script"

                                                                                                                                                                                                                                                                                    'onload-script'?: boolean | undefined;

                                                                                                                                                                                                                                                                                      property "proprietary-attribs"

                                                                                                                                                                                                                                                                                      'proprietary-attribs'?: boolean | undefined;

                                                                                                                                                                                                                                                                                        property "rebuild-bundle"

                                                                                                                                                                                                                                                                                        'rebuild-bundle'?: boolean | undefined;

                                                                                                                                                                                                                                                                                          property "save-bundle"

                                                                                                                                                                                                                                                                                          'save-bundle'?: boolean | undefined;

                                                                                                                                                                                                                                                                                            property "save-dev"

                                                                                                                                                                                                                                                                                            'save-dev'?: boolean | undefined;

                                                                                                                                                                                                                                                                                              property "save-exact"

                                                                                                                                                                                                                                                                                              'save-exact'?: boolean | undefined;

                                                                                                                                                                                                                                                                                                property "save-optional"

                                                                                                                                                                                                                                                                                                'save-optional'?: boolean | undefined;

                                                                                                                                                                                                                                                                                                  property "save-prefix"

                                                                                                                                                                                                                                                                                                  'save-prefix'?: string | undefined;

                                                                                                                                                                                                                                                                                                    property "sign-git-tag"

                                                                                                                                                                                                                                                                                                    'sign-git-tag'?: boolean | undefined;

                                                                                                                                                                                                                                                                                                      property "strict-ssl"

                                                                                                                                                                                                                                                                                                      'strict-ssl'?: boolean | undefined;

                                                                                                                                                                                                                                                                                                        property "unsafe-perm"

                                                                                                                                                                                                                                                                                                        'unsafe-perm'?: boolean | undefined;

                                                                                                                                                                                                                                                                                                          property "user-agent"

                                                                                                                                                                                                                                                                                                          'user-agent'?: string | undefined;

                                                                                                                                                                                                                                                                                                            property browser

                                                                                                                                                                                                                                                                                                            browser?: string | undefined;

                                                                                                                                                                                                                                                                                                              property ca

                                                                                                                                                                                                                                                                                                              ca?: any;

                                                                                                                                                                                                                                                                                                                property cache

                                                                                                                                                                                                                                                                                                                cache?: string | undefined;

                                                                                                                                                                                                                                                                                                                  property cafile

                                                                                                                                                                                                                                                                                                                  cafile?: string | undefined;

                                                                                                                                                                                                                                                                                                                    property cert

                                                                                                                                                                                                                                                                                                                    cert?: string | undefined;

                                                                                                                                                                                                                                                                                                                      property color

                                                                                                                                                                                                                                                                                                                      color?: any;

                                                                                                                                                                                                                                                                                                                        property depth

                                                                                                                                                                                                                                                                                                                        depth?: number | undefined;

                                                                                                                                                                                                                                                                                                                          property description

                                                                                                                                                                                                                                                                                                                          description?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                            property dev

                                                                                                                                                                                                                                                                                                                            dev?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                              property editor

                                                                                                                                                                                                                                                                                                                              editor?: string | undefined;

                                                                                                                                                                                                                                                                                                                                property force

                                                                                                                                                                                                                                                                                                                                force?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                  property git

                                                                                                                                                                                                                                                                                                                                  git?: string | undefined;

                                                                                                                                                                                                                                                                                                                                    property global

                                                                                                                                                                                                                                                                                                                                    global?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                      property globalconfig

                                                                                                                                                                                                                                                                                                                                      globalconfig?: string | undefined;

                                                                                                                                                                                                                                                                                                                                        property group

                                                                                                                                                                                                                                                                                                                                        group?: any;

                                                                                                                                                                                                                                                                                                                                          property heading

                                                                                                                                                                                                                                                                                                                                          heading?: string | undefined;

                                                                                                                                                                                                                                                                                                                                            property json

                                                                                                                                                                                                                                                                                                                                            json?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                              property key

                                                                                                                                                                                                                                                                                                                                              key?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                link?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                  property loglevel

                                                                                                                                                                                                                                                                                                                                                  loglevel?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                    property logstream

                                                                                                                                                                                                                                                                                                                                                    logstream?: NodeJS.ReadWriteStream | undefined;

                                                                                                                                                                                                                                                                                                                                                      property long

                                                                                                                                                                                                                                                                                                                                                      long?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                        property message

                                                                                                                                                                                                                                                                                                                                                        message?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                          property npat

                                                                                                                                                                                                                                                                                                                                                          npat?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                            property optional

                                                                                                                                                                                                                                                                                                                                                            optional?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                              property parseable

                                                                                                                                                                                                                                                                                                                                                              parseable?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                property prefix

                                                                                                                                                                                                                                                                                                                                                                prefix?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                  property production

                                                                                                                                                                                                                                                                                                                                                                  production?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                    property proxy

                                                                                                                                                                                                                                                                                                                                                                    proxy?: any;

                                                                                                                                                                                                                                                                                                                                                                      property registry

                                                                                                                                                                                                                                                                                                                                                                      registry?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                        property rollback

                                                                                                                                                                                                                                                                                                                                                                        rollback?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                          property save

                                                                                                                                                                                                                                                                                                                                                                          save?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                            property scope

                                                                                                                                                                                                                                                                                                                                                                            scope?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                              property searchexclude

                                                                                                                                                                                                                                                                                                                                                                              searchexclude?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                property searchopts

                                                                                                                                                                                                                                                                                                                                                                                searchopts?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                  property searchsort

                                                                                                                                                                                                                                                                                                                                                                                  searchsort?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                    property shell

                                                                                                                                                                                                                                                                                                                                                                                    shell?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                      property shrinkwrap

                                                                                                                                                                                                                                                                                                                                                                                      shrinkwrap?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                        property spin

                                                                                                                                                                                                                                                                                                                                                                                        spin?: any;

                                                                                                                                                                                                                                                                                                                                                                                          property tag

                                                                                                                                                                                                                                                                                                                                                                                          tag?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                            property tmp

                                                                                                                                                                                                                                                                                                                                                                                            tmp?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                              property umask

                                                                                                                                                                                                                                                                                                                                                                                              umask?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                property unicode

                                                                                                                                                                                                                                                                                                                                                                                                unicode?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                  property usage

                                                                                                                                                                                                                                                                                                                                                                                                  usage?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                    property user

                                                                                                                                                                                                                                                                                                                                                                                                    user?: any;

                                                                                                                                                                                                                                                                                                                                                                                                      property userconfig

                                                                                                                                                                                                                                                                                                                                                                                                      userconfig?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                        property version

                                                                                                                                                                                                                                                                                                                                                                                                        version?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                          property versions

                                                                                                                                                                                                                                                                                                                                                                                                          versions?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                            property viewer

                                                                                                                                                                                                                                                                                                                                                                                                            viewer?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                              interface ConfigShorthands

                                                                                                                                                                                                                                                                                                                                                                                                              interface ConfigShorthands {}

                                                                                                                                                                                                                                                                                                                                                                                                                property "?"

                                                                                                                                                                                                                                                                                                                                                                                                                '?': any[];

                                                                                                                                                                                                                                                                                                                                                                                                                  property "local"

                                                                                                                                                                                                                                                                                                                                                                                                                  local: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                    property "no-desc"

                                                                                                                                                                                                                                                                                                                                                                                                                    'no-desc': any[];

                                                                                                                                                                                                                                                                                                                                                                                                                      property "no-reg"

                                                                                                                                                                                                                                                                                                                                                                                                                      'no-reg': any[];

                                                                                                                                                                                                                                                                                                                                                                                                                        property B

                                                                                                                                                                                                                                                                                                                                                                                                                        B: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                          property C

                                                                                                                                                                                                                                                                                                                                                                                                                          C: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                            property d

                                                                                                                                                                                                                                                                                                                                                                                                                            d: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                              property D

                                                                                                                                                                                                                                                                                                                                                                                                                              D: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                property dd

                                                                                                                                                                                                                                                                                                                                                                                                                                dd: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                  property ddd

                                                                                                                                                                                                                                                                                                                                                                                                                                  ddd: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                    property desc

                                                                                                                                                                                                                                                                                                                                                                                                                                    desc: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                      property E

                                                                                                                                                                                                                                                                                                                                                                                                                                      E: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                        property f

                                                                                                                                                                                                                                                                                                                                                                                                                                        f: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                          property g

                                                                                                                                                                                                                                                                                                                                                                                                                                          g: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                            property gangsta

                                                                                                                                                                                                                                                                                                                                                                                                                                            gangsta: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                              property gangster

                                                                                                                                                                                                                                                                                                                                                                                                                                              gangster: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                property h

                                                                                                                                                                                                                                                                                                                                                                                                                                                h: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property H

                                                                                                                                                                                                                                                                                                                                                                                                                                                  H: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property help

                                                                                                                                                                                                                                                                                                                                                                                                                                                    help: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property l

                                                                                                                                                                                                                                                                                                                                                                                                                                                      l: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property m

                                                                                                                                                                                                                                                                                                                                                                                                                                                        m: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property n

                                                                                                                                                                                                                                                                                                                                                                                                                                                          n: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property N

                                                                                                                                                                                                                                                                                                                                                                                                                                                            N: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property noreg

                                                                                                                                                                                                                                                                                                                                                                                                                                                              noreg: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property O

                                                                                                                                                                                                                                                                                                                                                                                                                                                                O: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property p

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  p: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property porcelain

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    porcelain: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property q

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      q: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property quiet

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        quiet: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property reg

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          reg: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            s: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property S

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              S: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property silent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                silent: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property v

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  v: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property verbose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    verbose: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property y

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      y: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ConfigSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ConfigSource {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          path: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ConfigStatic

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ConfigStatic {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                construct signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                new (base: Config): Config;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (base: Config): Config;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ConfigTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ConfigTypes {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property "always-auth"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'always-auth': typeof Boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property "bin-links"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        'bin-links': typeof Boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property "cache-lock-retries"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'cache-lock-retries': typeof Number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property "cache-lock-stale"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'cache-lock-stale': typeof Number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property "cache-lock-wait"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              'cache-lock-wait': typeof Number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property "cache-max"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                'cache-max': typeof Number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property "cache-min"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  'cache-min': typeof Number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property "engine-strict"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'engine-strict': typeof Boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property "fetch-retries"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'fetch-retries': typeof Number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property "fetch-retry-factor"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        'fetch-retry-factor': typeof Number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property "fetch-retry-maxtimeout"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'fetch-retry-maxtimeout': typeof Number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property "fetch-retry-mintimeout"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'fetch-retry-mintimeout': typeof Number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property "git-tag-version"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              'git-tag-version': typeof Boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property "https-proxy"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                'https-proxy': any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property "ignore-scripts"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  'ignore-scripts': typeof Boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property "init-module"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'init-module': typeof String;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property "init.author.email"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'init.author.email': typeof String;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property "init.author.name"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        'init.author.name': typeof String;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property "init.author.url"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'init.author.url': typeof String;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property "init.license"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'init.license': typeof String;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property "init.version"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              'init.version': typeof String;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property "local-address"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                'local-address': typeof String;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property "node-version"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  'node-version': any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property "onload-script"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'onload-script': any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property "proprietary-attribs"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'proprietary-attribs': typeof Boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property "rebuild-bundle"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        'rebuild-bundle': Boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property "save-bundle"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'save-bundle': typeof Boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property "save-dev"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'save-dev': typeof Boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property "save-exact"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              'save-exact': typeof Boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property "save-optional"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                'save-optional': typeof Boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property "save-prefix"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  'save-prefix': typeof String;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property "sign-git-tag"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'sign-git-tag': typeof Boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property "strict-ssl"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'strict-ssl': typeof Boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property "unsafe-perm"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        'unsafe-perm': typeof Boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property "user-agent"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'user-agent': typeof String;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property browser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            browser: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property ca

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ca: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property cache

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                cache: typeof String;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property cafile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  cafile: typeof String;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property cert

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cert: typeof String;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property color

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      color: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property depth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        depth: typeof Number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property description

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          description: typeof Boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property dev

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            dev: typeof Boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property editor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              editor: typeof String;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property force

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                force: typeof Boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property git

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  git: typeof String;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property global

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    global: typeof Boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property globalconfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      globalconfig: typeof String;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property group

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        group: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property heading

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          heading: typeof String;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property json

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            json: typeof Boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property key

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              key: any[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                link: typeof Boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property loglevel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  loglevel: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property logstream

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    logstream: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property long

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      long: typeof Boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property message

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        message: typeof String;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property npat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          npat: typeof Boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property optional

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            optional: typeof Boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property parseable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              parseable: typeof Boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property prefix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                prefix: typeof String;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property production

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  production: typeof Boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property proxy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    proxy: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property registry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      registry: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property rollback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        rollback: typeof Boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property save

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          save: typeof Boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property scope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            scope: typeof String;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property searchexclude

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              searchexclude: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property searchopts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                searchopts: typeof String;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property searchsort

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  searchsort: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property shell

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    shell: typeof String;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property shrinkwrap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      shrinkwrap: typeof Boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property spin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        spin: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          tag: typeof String;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property tmp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            tmp: typeof String;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property umask

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              umask: typeof Number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property unicode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                unicode: typeof Boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property usage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  usage: typeof Boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property user

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    user: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property userconfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      userconfig: typeof String;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property version

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        version: typeof Boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property versions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          versions: typeof Boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property viewer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            viewer: typeof String;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface Credentials

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface Credentials {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property auth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                auth?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property email

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  email?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property password

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    password?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property scope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      scope: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property token

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        token?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property username

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          username?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Dictionary

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Dictionary<T> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [key: string]: T;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ErrorCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ErrorCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (err?: Error): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SimpleCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SimpleCallback<T> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (err?: Error, result?: T): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Spinner

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Spinner {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          int: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property started

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            started: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method start

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              start: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method stop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                stop: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Static

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Static extends NodeJS.EventEmitter {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property abbrevs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    abbrevs: Dictionary<string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property bin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      bin: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property cache

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        cache: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property commands

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          commands: Commands;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property config

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            config: Config;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property dir

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              dir: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property fullList

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                fullList: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property globalBin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  globalBin: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property globalDir

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    globalDir: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property prefix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      prefix: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property rollbacks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        rollbacks: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property root

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          root: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property spinner

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            spinner: Spinner;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property tmp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              tmp: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method deref

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                deref: (command: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method load

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  load: (callback?: SimpleCallback<void>) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Package Files (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Dependencies (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    No dev dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Badge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    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/npm.

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