@oclif/config

  • Version 1.17.0
  • Published
  • 115 kB
  • 6 dependencies
  • MIT license

Install

npm i @oclif/config
yarn add @oclif/config
pnpm add @oclif/config

Overview

base config object and standard interfaces for oclif components

Index

Functions

Classes

Interfaces

Type Aliases

Namespaces

Functions

function load

load: (opts?: LoadOptions) => Promise<IConfig | Config>;

    Classes

    class Config

    class Config implements IConfig {}

      constructor

      constructor(options: Options);

        property arch

        arch: ArchTypes;

          property bin

          bin: string;

            property binPath

            binPath?: string;

              property cacheDir

              cacheDir: string;

                property channel

                channel: string;

                  property commandIDs

                  readonly commandIDs: string[];

                    property commands

                    readonly commands: Command.Plugin[];

                      property configDir

                      configDir: string;

                        property dataDir

                        dataDir: string;

                          property debug

                          debug: number;

                            property dirname

                            dirname: string;

                              property errlog

                              errlog: string;

                                property home

                                home: string;

                                  property name

                                  name: string;

                                    property npmRegistry

                                    npmRegistry?: string;

                                      property options

                                      options: Options;

                                        property pjson

                                        pjson: PJSON.CLI;

                                          property platform

                                          platform: PlatformTypes;

                                            property plugins

                                            plugins: Plugin.IPlugin[];

                                              property root

                                              root: string;

                                                property shell

                                                shell: string;

                                                  property topics

                                                  readonly topics: Topic[];

                                                    property userAgent

                                                    userAgent: string;

                                                      property userPJSON

                                                      userPJSON?: PJSON.User;

                                                        property valid

                                                        valid: boolean;

                                                          property version

                                                          version: string;

                                                            property warned

                                                            protected warned: boolean;

                                                              property windows

                                                              windows: boolean;

                                                                method dir

                                                                protected dir: (category: 'cache' | 'data' | 'config') => string;

                                                                  method findCommand

                                                                  findCommand: {
                                                                  (id: string, opts: { must: true }): Command.Plugin;
                                                                  (id: string, opts?: { must: boolean }): Command.Plugin;
                                                                  };

                                                                    method findTopic

                                                                    findTopic: {
                                                                    (id: string, opts: { must: true }): Topic;
                                                                    (id: string, opts?: { must: boolean }): Topic;
                                                                    };

                                                                      method load

                                                                      load: () => Promise<void>;

                                                                        method loadCorePlugins

                                                                        loadCorePlugins: () => Promise<void>;

                                                                          method loadDevPlugins

                                                                          loadDevPlugins: () => Promise<void>;

                                                                            method loadPlugins

                                                                            protected loadPlugins: (
                                                                            root: string,
                                                                            type: string,
                                                                            plugins: (string | { root?: string; name?: string; tag?: string })[],
                                                                            parent?: Plugin.Plugin
                                                                            ) => Promise<void>;

                                                                              method loadUserPlugins

                                                                              loadUserPlugins: () => Promise<void>;

                                                                                method macosCacheDir

                                                                                protected macosCacheDir: () => string | undefined;

                                                                                  method runCommand

                                                                                  runCommand: (id: string, argv?: string[]) => Promise<void>;

                                                                                    method runHook

                                                                                    runHook: <T>(event: string, opts: T) => Promise<void>;

                                                                                      method s3Key

                                                                                      s3Key: (
                                                                                      type: keyof PJSON.S3.Templates,
                                                                                      ext?: '.tar.gz' | '.tar.xz' | IConfig.s3Key.Options,
                                                                                      options?: IConfig.s3Key.Options
                                                                                      ) => string;

                                                                                        method s3Url

                                                                                        s3Url: (key: string) => string;

                                                                                          method scopedEnvVar

                                                                                          scopedEnvVar: (k: string) => string | undefined;

                                                                                            method scopedEnvVarKey

                                                                                            scopedEnvVarKey: (k: string) => string;

                                                                                              method scopedEnvVarTrue

                                                                                              scopedEnvVarTrue: (k: string) => boolean;

                                                                                                method warn

                                                                                                protected warn: (
                                                                                                err: string | Error | { name: string; detail: string },
                                                                                                scope?: string
                                                                                                ) => void;

                                                                                                  method windowsHome

                                                                                                  protected windowsHome: () => string | undefined;

                                                                                                    method windowsHomedriveHome

                                                                                                    protected windowsHomedriveHome: () => string | undefined;

                                                                                                      method windowsUserprofileHome

                                                                                                      protected windowsUserprofileHome: () => string | undefined;

                                                                                                        class Plugin

                                                                                                        class Plugin implements IPlugin {}

                                                                                                          constructor

                                                                                                          constructor(options: Options);

                                                                                                            property alreadyLoaded

                                                                                                            alreadyLoaded: boolean;

                                                                                                              property children

                                                                                                              children: Plugin[];

                                                                                                                property commandIDs

                                                                                                                readonly commandIDs: string[];

                                                                                                                  property commands

                                                                                                                  commands: Command.Plugin[];

                                                                                                                    property commandsDir

                                                                                                                    readonly commandsDir: string;

                                                                                                                      property hooks

                                                                                                                      hooks: { [k: string]: string[] };

                                                                                                                        property manifest

                                                                                                                        manifest: Manifest;

                                                                                                                          property name

                                                                                                                          name: string;

                                                                                                                            property options

                                                                                                                            options: Options;

                                                                                                                              property parent

                                                                                                                              parent: Plugin;

                                                                                                                                property pjson

                                                                                                                                pjson: PJSON.Plugin;

                                                                                                                                  property root

                                                                                                                                  root: string;

                                                                                                                                    property tag

                                                                                                                                    tag?: string;

                                                                                                                                      property topics

                                                                                                                                      readonly topics: Topic[];

                                                                                                                                        property type

                                                                                                                                        type: string;

                                                                                                                                          property valid

                                                                                                                                          valid: boolean;

                                                                                                                                            property version

                                                                                                                                            version: string;

                                                                                                                                              property warned

                                                                                                                                              protected warned: boolean;

                                                                                                                                                method findCommand

                                                                                                                                                findCommand: {
                                                                                                                                                (id: string, opts: { must: true }): Command.Class;
                                                                                                                                                (id: string, opts?: { must: boolean }): Command.Class;
                                                                                                                                                };

                                                                                                                                                  method load

                                                                                                                                                  load: () => Promise<void>;

                                                                                                                                                    method warn

                                                                                                                                                    protected warn: (err: any, scope?: string) => void;

                                                                                                                                                      Interfaces

                                                                                                                                                      interface Command

                                                                                                                                                      interface Command {}

                                                                                                                                                        property aliases

                                                                                                                                                        aliases: string[];

                                                                                                                                                          property args

                                                                                                                                                          args: Command.Arg[];

                                                                                                                                                            property description

                                                                                                                                                            description?: string;

                                                                                                                                                              property examples

                                                                                                                                                              examples?: string[];

                                                                                                                                                                property flags

                                                                                                                                                                flags: {
                                                                                                                                                                [name: string]: Command.Flag;
                                                                                                                                                                };

                                                                                                                                                                  property hidden

                                                                                                                                                                  hidden: boolean;

                                                                                                                                                                    property id

                                                                                                                                                                    id: string;

                                                                                                                                                                      property pluginName

                                                                                                                                                                      pluginName?: string;

                                                                                                                                                                        property pluginType

                                                                                                                                                                        pluginType?: string;

                                                                                                                                                                          property type

                                                                                                                                                                          type?: string;

                                                                                                                                                                            property usage

                                                                                                                                                                            usage?: string | string[];

                                                                                                                                                                              interface Hooks

                                                                                                                                                                              interface Hooks {}

                                                                                                                                                                                property 'command_not_found'

                                                                                                                                                                                command_not_found: {
                                                                                                                                                                                id: string;
                                                                                                                                                                                };

                                                                                                                                                                                  property 'plugins:preinstall'

                                                                                                                                                                                  'plugins:preinstall': {
                                                                                                                                                                                  plugin:
                                                                                                                                                                                  | {
                                                                                                                                                                                  name: string;
                                                                                                                                                                                  tag: string;
                                                                                                                                                                                  type: 'npm';
                                                                                                                                                                                  }
                                                                                                                                                                                  | {
                                                                                                                                                                                  url: string;
                                                                                                                                                                                  type: 'repo';
                                                                                                                                                                                  };
                                                                                                                                                                                  };

                                                                                                                                                                                    property init

                                                                                                                                                                                    init: {
                                                                                                                                                                                    id: string | undefined;
                                                                                                                                                                                    argv: string[];
                                                                                                                                                                                    };

                                                                                                                                                                                      property postrun

                                                                                                                                                                                      postrun: {
                                                                                                                                                                                      Command: Config.Command.Class;
                                                                                                                                                                                      result?: any;
                                                                                                                                                                                      argv: string[];
                                                                                                                                                                                      };

                                                                                                                                                                                        property prerun

                                                                                                                                                                                        prerun: {
                                                                                                                                                                                        Command: Config.Command.Class;
                                                                                                                                                                                        argv: string[];
                                                                                                                                                                                        };

                                                                                                                                                                                          property preupdate

                                                                                                                                                                                          preupdate: {
                                                                                                                                                                                          channel: string;
                                                                                                                                                                                          };

                                                                                                                                                                                            property update

                                                                                                                                                                                            update: {
                                                                                                                                                                                            channel: string;
                                                                                                                                                                                            };

                                                                                                                                                                                              index signature

                                                                                                                                                                                              [event: string]: object;

                                                                                                                                                                                                interface IConfig

                                                                                                                                                                                                interface IConfig {}

                                                                                                                                                                                                  property arch

                                                                                                                                                                                                  arch: ArchTypes;
                                                                                                                                                                                                  • process.arch

                                                                                                                                                                                                  property bin

                                                                                                                                                                                                  bin: string;
                                                                                                                                                                                                  • bin name of CLI command

                                                                                                                                                                                                  property binPath

                                                                                                                                                                                                  binPath?: string;

                                                                                                                                                                                                    property cacheDir

                                                                                                                                                                                                    cacheDir: string;
                                                                                                                                                                                                    • cache directory to use for CLI

                                                                                                                                                                                                      example ~/Library/Caches/mycli or ~/.cache/mycli

                                                                                                                                                                                                    property channel

                                                                                                                                                                                                    channel: string;

                                                                                                                                                                                                      property commandIDs

                                                                                                                                                                                                      readonly commandIDs: string[];

                                                                                                                                                                                                        property commands

                                                                                                                                                                                                        readonly commands: Command.Plugin[];

                                                                                                                                                                                                          property configDir

                                                                                                                                                                                                          configDir: string;
                                                                                                                                                                                                          • config directory to use for CLI

                                                                                                                                                                                                            example: ~/.config/mycli

                                                                                                                                                                                                          property dataDir

                                                                                                                                                                                                          dataDir: string;
                                                                                                                                                                                                          • data directory to use for CLI

                                                                                                                                                                                                            example: ~/.local/share/mycli

                                                                                                                                                                                                          property debug

                                                                                                                                                                                                          debug: number;
                                                                                                                                                                                                          • debugging level

                                                                                                                                                                                                            set by ${BIN}_DEBUG or DEBUG=$BIN

                                                                                                                                                                                                          property dirname

                                                                                                                                                                                                          dirname: string;
                                                                                                                                                                                                          • base dirname to use in cacheDir/configDir/dataDir

                                                                                                                                                                                                          property errlog

                                                                                                                                                                                                          errlog: string;
                                                                                                                                                                                                          • points to a file that should be appended to for error logs

                                                                                                                                                                                                            example: ~/Library/Caches/mycli/error.log

                                                                                                                                                                                                          property home

                                                                                                                                                                                                          home: string;
                                                                                                                                                                                                          • path to home directory

                                                                                                                                                                                                            example: /home/myuser

                                                                                                                                                                                                          property name

                                                                                                                                                                                                          name: string;

                                                                                                                                                                                                            property npmRegistry

                                                                                                                                                                                                            npmRegistry?: string;
                                                                                                                                                                                                            • npm registry to use for installing plugins

                                                                                                                                                                                                            property pjson

                                                                                                                                                                                                            pjson: PJSON.CLI;

                                                                                                                                                                                                              property platform

                                                                                                                                                                                                              platform: PlatformTypes;
                                                                                                                                                                                                              • process.platform

                                                                                                                                                                                                              property plugins

                                                                                                                                                                                                              plugins: Plugin.IPlugin[];

                                                                                                                                                                                                                property root

                                                                                                                                                                                                                root: string;

                                                                                                                                                                                                                  property shell

                                                                                                                                                                                                                  shell: string;
                                                                                                                                                                                                                  • active shell

                                                                                                                                                                                                                  property topics

                                                                                                                                                                                                                  readonly topics: Topic[];

                                                                                                                                                                                                                    property userAgent

                                                                                                                                                                                                                    userAgent: string;
                                                                                                                                                                                                                    • user agent to use for http calls

                                                                                                                                                                                                                      example: mycli/1.2.3 (darwin-x64) node-9.0.0

                                                                                                                                                                                                                    property userPJSON

                                                                                                                                                                                                                    userPJSON?: PJSON.User;

                                                                                                                                                                                                                      property valid

                                                                                                                                                                                                                      valid: boolean;

                                                                                                                                                                                                                        property version

                                                                                                                                                                                                                        version: string;

                                                                                                                                                                                                                          property windows

                                                                                                                                                                                                                          windows: boolean;
                                                                                                                                                                                                                          • if windows

                                                                                                                                                                                                                          method findCommand

                                                                                                                                                                                                                          findCommand: {
                                                                                                                                                                                                                          (id: string, opts: { must: true }): Command.Plugin;
                                                                                                                                                                                                                          (id: string, opts?: { must: boolean }): Command.Plugin;
                                                                                                                                                                                                                          };

                                                                                                                                                                                                                            method findTopic

                                                                                                                                                                                                                            findTopic: {
                                                                                                                                                                                                                            (id: string, opts: { must: true }): Topic;
                                                                                                                                                                                                                            (id: string, opts?: { must: boolean }): Topic;
                                                                                                                                                                                                                            };

                                                                                                                                                                                                                              method runCommand

                                                                                                                                                                                                                              runCommand: (id: string, argv?: string[]) => Promise<void>;

                                                                                                                                                                                                                                method runHook

                                                                                                                                                                                                                                runHook: <T extends Hooks, K extends Extract<keyof T, string>>(
                                                                                                                                                                                                                                event: K,
                                                                                                                                                                                                                                opts: T[K]
                                                                                                                                                                                                                                ) => Promise<void>;

                                                                                                                                                                                                                                  method s3Key

                                                                                                                                                                                                                                  s3Key: {
                                                                                                                                                                                                                                  (
                                                                                                                                                                                                                                  type: 'versioned' | 'unversioned',
                                                                                                                                                                                                                                  ext: '.tar.gz' | '.tar.xz',
                                                                                                                                                                                                                                  options?: IConfig.s3Key.Options
                                                                                                                                                                                                                                  ): string;
                                                                                                                                                                                                                                  (type: keyof PJSON.S3.Templates, options?: IConfig.s3Key.Options): string;
                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                    method s3Url

                                                                                                                                                                                                                                    s3Url: (key: string) => string;

                                                                                                                                                                                                                                      method scopedEnvVar

                                                                                                                                                                                                                                      scopedEnvVar: (key: string) => string | undefined;

                                                                                                                                                                                                                                        method scopedEnvVarKey

                                                                                                                                                                                                                                        scopedEnvVarKey: (key: string) => string;

                                                                                                                                                                                                                                          method scopedEnvVarTrue

                                                                                                                                                                                                                                          scopedEnvVarTrue: (key: string) => boolean;

                                                                                                                                                                                                                                            interface IPlugin

                                                                                                                                                                                                                                            interface IPlugin {}

                                                                                                                                                                                                                                              property commandIDs

                                                                                                                                                                                                                                              readonly commandIDs: string[];

                                                                                                                                                                                                                                                property commands

                                                                                                                                                                                                                                                commands: Command.Plugin[];

                                                                                                                                                                                                                                                  property hooks

                                                                                                                                                                                                                                                  hooks: {
                                                                                                                                                                                                                                                  [k: string]: string[];
                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                    property name

                                                                                                                                                                                                                                                    name: string;
                                                                                                                                                                                                                                                    • name from package.json

                                                                                                                                                                                                                                                    property pjson

                                                                                                                                                                                                                                                    pjson: PJSON.Plugin | PJSON.CLI;
                                                                                                                                                                                                                                                    • full package.json

                                                                                                                                                                                                                                                      parsed with read-pkg

                                                                                                                                                                                                                                                    property root

                                                                                                                                                                                                                                                    root: string;
                                                                                                                                                                                                                                                    • base path of plugin

                                                                                                                                                                                                                                                    property tag

                                                                                                                                                                                                                                                    tag?: string;
                                                                                                                                                                                                                                                    • npm dist-tag of plugin only used for user plugins

                                                                                                                                                                                                                                                    property topics

                                                                                                                                                                                                                                                    readonly topics: Topic[];

                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                      type: string;
                                                                                                                                                                                                                                                      • used to tell the user how the plugin was installed examples: core, link, user, dev

                                                                                                                                                                                                                                                      property valid

                                                                                                                                                                                                                                                      valid: boolean;
                                                                                                                                                                                                                                                      • if it appears to be an npm package but does not look like it's really a CLI plugin, this is set to false

                                                                                                                                                                                                                                                      property version

                                                                                                                                                                                                                                                      version: string;
                                                                                                                                                                                                                                                      • version from package.json

                                                                                                                                                                                                                                                        example: 1.2.3

                                                                                                                                                                                                                                                      method findCommand

                                                                                                                                                                                                                                                      findCommand: {
                                                                                                                                                                                                                                                      (id: string, opts: { must: true }): Command.Class;
                                                                                                                                                                                                                                                      (id: string, opts?: { must: boolean }): Command.Class;
                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                        method load

                                                                                                                                                                                                                                                        load: () => Promise<void>;

                                                                                                                                                                                                                                                          interface Manifest

                                                                                                                                                                                                                                                          interface Manifest {}

                                                                                                                                                                                                                                                            property commands

                                                                                                                                                                                                                                                            commands: {
                                                                                                                                                                                                                                                            [id: string]: Command;
                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                              property version

                                                                                                                                                                                                                                                              version: string;

                                                                                                                                                                                                                                                                interface Options

                                                                                                                                                                                                                                                                interface Options extends Plugin.Options {}

                                                                                                                                                                                                                                                                  property channel

                                                                                                                                                                                                                                                                  channel?: string;

                                                                                                                                                                                                                                                                    property devPlugins

                                                                                                                                                                                                                                                                    devPlugins?: boolean;

                                                                                                                                                                                                                                                                      property userPlugins

                                                                                                                                                                                                                                                                      userPlugins?: boolean;

                                                                                                                                                                                                                                                                        property version

                                                                                                                                                                                                                                                                        version?: string;

                                                                                                                                                                                                                                                                          interface PJSON

                                                                                                                                                                                                                                                                          interface PJSON {}

                                                                                                                                                                                                                                                                            property dependencies

                                                                                                                                                                                                                                                                            dependencies?: {
                                                                                                                                                                                                                                                                            [name: string]: string;
                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                              property oclif

                                                                                                                                                                                                                                                                              oclif: {
                                                                                                                                                                                                                                                                              schema?: number;
                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                index signature

                                                                                                                                                                                                                                                                                [k: string]: any;

                                                                                                                                                                                                                                                                                  interface Topic

                                                                                                                                                                                                                                                                                  interface Topic {}

                                                                                                                                                                                                                                                                                    property description

                                                                                                                                                                                                                                                                                    description?: string;

                                                                                                                                                                                                                                                                                      property hidden

                                                                                                                                                                                                                                                                                      hidden?: boolean;

                                                                                                                                                                                                                                                                                        property name

                                                                                                                                                                                                                                                                                        name: string;

                                                                                                                                                                                                                                                                                          Type Aliases

                                                                                                                                                                                                                                                                                          type ArchTypes

                                                                                                                                                                                                                                                                                          type ArchTypes =
                                                                                                                                                                                                                                                                                          | 'arm'
                                                                                                                                                                                                                                                                                          | 'arm64'
                                                                                                                                                                                                                                                                                          | 'mips'
                                                                                                                                                                                                                                                                                          | 'mipsel'
                                                                                                                                                                                                                                                                                          | 'ppc'
                                                                                                                                                                                                                                                                                          | 'ppc64'
                                                                                                                                                                                                                                                                                          | 's390'
                                                                                                                                                                                                                                                                                          | 's390x'
                                                                                                                                                                                                                                                                                          | 'x32'
                                                                                                                                                                                                                                                                                          | 'x64'
                                                                                                                                                                                                                                                                                          | 'x86';

                                                                                                                                                                                                                                                                                            type Hook

                                                                                                                                                                                                                                                                                            type Hook<T> = (
                                                                                                                                                                                                                                                                                            this: Hook.Context,
                                                                                                                                                                                                                                                                                            options: HookKeyOrOptions<T> & {
                                                                                                                                                                                                                                                                                            config: Config.IConfig;
                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                            ) => any;

                                                                                                                                                                                                                                                                                              type LoadOptions

                                                                                                                                                                                                                                                                                              type LoadOptions = Options | string | IConfig | undefined;

                                                                                                                                                                                                                                                                                                type PlatformTypes

                                                                                                                                                                                                                                                                                                type PlatformTypes =
                                                                                                                                                                                                                                                                                                | 'darwin'
                                                                                                                                                                                                                                                                                                | 'linux'
                                                                                                                                                                                                                                                                                                | 'win32'
                                                                                                                                                                                                                                                                                                | 'aix'
                                                                                                                                                                                                                                                                                                | 'freebsd'
                                                                                                                                                                                                                                                                                                | 'openbsd'
                                                                                                                                                                                                                                                                                                | 'sunos'
                                                                                                                                                                                                                                                                                                | 'wsl';

                                                                                                                                                                                                                                                                                                  Namespaces

                                                                                                                                                                                                                                                                                                  namespace Command

                                                                                                                                                                                                                                                                                                  namespace Command {}

                                                                                                                                                                                                                                                                                                    function toCached

                                                                                                                                                                                                                                                                                                    toCached: (c: Class, plugin?: Config.Plugin) => Command;

                                                                                                                                                                                                                                                                                                      interface Arg

                                                                                                                                                                                                                                                                                                      interface Arg {}

                                                                                                                                                                                                                                                                                                        property default

                                                                                                                                                                                                                                                                                                        default?: string;

                                                                                                                                                                                                                                                                                                          property description

                                                                                                                                                                                                                                                                                                          description?: string;

                                                                                                                                                                                                                                                                                                            property hidden

                                                                                                                                                                                                                                                                                                            hidden?: boolean;

                                                                                                                                                                                                                                                                                                              property name

                                                                                                                                                                                                                                                                                                              name: string;

                                                                                                                                                                                                                                                                                                                property options

                                                                                                                                                                                                                                                                                                                options?: string[];

                                                                                                                                                                                                                                                                                                                  property required

                                                                                                                                                                                                                                                                                                                  required?: boolean;

                                                                                                                                                                                                                                                                                                                    interface Base

                                                                                                                                                                                                                                                                                                                    interface Base {}

                                                                                                                                                                                                                                                                                                                      property aliases

                                                                                                                                                                                                                                                                                                                      aliases: string[];

                                                                                                                                                                                                                                                                                                                        property description

                                                                                                                                                                                                                                                                                                                        description?: string;

                                                                                                                                                                                                                                                                                                                          property examples

                                                                                                                                                                                                                                                                                                                          examples?: string[];

                                                                                                                                                                                                                                                                                                                            property hidden

                                                                                                                                                                                                                                                                                                                            hidden: boolean;

                                                                                                                                                                                                                                                                                                                              property id

                                                                                                                                                                                                                                                                                                                              id: string;

                                                                                                                                                                                                                                                                                                                                property usage

                                                                                                                                                                                                                                                                                                                                usage?: string | string[];

                                                                                                                                                                                                                                                                                                                                  interface Class

                                                                                                                                                                                                                                                                                                                                  interface Class extends Base {}

                                                                                                                                                                                                                                                                                                                                    property args

                                                                                                                                                                                                                                                                                                                                    args?: Parser.args.Input;

                                                                                                                                                                                                                                                                                                                                      property flags

                                                                                                                                                                                                                                                                                                                                      flags?: Parser.flags.Input<any>;

                                                                                                                                                                                                                                                                                                                                        property plugin

                                                                                                                                                                                                                                                                                                                                        plugin?: Config.IPlugin;

                                                                                                                                                                                                                                                                                                                                          method run

                                                                                                                                                                                                                                                                                                                                          run: (argv?: string[], config?: Config.LoadOptions) => PromiseLike<any>;

                                                                                                                                                                                                                                                                                                                                            construct signature

                                                                                                                                                                                                                                                                                                                                            new (argv: string[], config: Config.IConfig): Instance;

                                                                                                                                                                                                                                                                                                                                              interface Instance

                                                                                                                                                                                                                                                                                                                                              interface Instance {}

                                                                                                                                                                                                                                                                                                                                                interface Plugin

                                                                                                                                                                                                                                                                                                                                                interface Plugin extends Command {}

                                                                                                                                                                                                                                                                                                                                                  method load

                                                                                                                                                                                                                                                                                                                                                  load: () => Class;

                                                                                                                                                                                                                                                                                                                                                    type Flag

                                                                                                                                                                                                                                                                                                                                                    type Flag = Flag.Boolean | Flag.Option;

                                                                                                                                                                                                                                                                                                                                                      namespace Command.Flag

                                                                                                                                                                                                                                                                                                                                                      namespace Command.Flag {}

                                                                                                                                                                                                                                                                                                                                                        interface Boolean

                                                                                                                                                                                                                                                                                                                                                        interface Boolean {}

                                                                                                                                                                                                                                                                                                                                                          property allowNo

                                                                                                                                                                                                                                                                                                                                                          allowNo?: boolean;

                                                                                                                                                                                                                                                                                                                                                            property char

                                                                                                                                                                                                                                                                                                                                                            char?: string;

                                                                                                                                                                                                                                                                                                                                                              property description

                                                                                                                                                                                                                                                                                                                                                              description?: string;

                                                                                                                                                                                                                                                                                                                                                                property helpLabel

                                                                                                                                                                                                                                                                                                                                                                helpLabel?: string;

                                                                                                                                                                                                                                                                                                                                                                  property hidden

                                                                                                                                                                                                                                                                                                                                                                  hidden?: boolean;

                                                                                                                                                                                                                                                                                                                                                                    property name

                                                                                                                                                                                                                                                                                                                                                                    name: string;

                                                                                                                                                                                                                                                                                                                                                                      property required

                                                                                                                                                                                                                                                                                                                                                                      required?: boolean;

                                                                                                                                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                                                                                                                                        type: 'boolean';

                                                                                                                                                                                                                                                                                                                                                                          interface Option

                                                                                                                                                                                                                                                                                                                                                                          interface Option {}

                                                                                                                                                                                                                                                                                                                                                                            property char

                                                                                                                                                                                                                                                                                                                                                                            char?: string;

                                                                                                                                                                                                                                                                                                                                                                              property default

                                                                                                                                                                                                                                                                                                                                                                              default?: string;

                                                                                                                                                                                                                                                                                                                                                                                property description

                                                                                                                                                                                                                                                                                                                                                                                description?: string;

                                                                                                                                                                                                                                                                                                                                                                                  property helpLabel

                                                                                                                                                                                                                                                                                                                                                                                  helpLabel?: string;

                                                                                                                                                                                                                                                                                                                                                                                    property helpValue

                                                                                                                                                                                                                                                                                                                                                                                    helpValue?: string;

                                                                                                                                                                                                                                                                                                                                                                                      property hidden

                                                                                                                                                                                                                                                                                                                                                                                      hidden?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                        property name

                                                                                                                                                                                                                                                                                                                                                                                        name: string;

                                                                                                                                                                                                                                                                                                                                                                                          property options

                                                                                                                                                                                                                                                                                                                                                                                          options?: string[];

                                                                                                                                                                                                                                                                                                                                                                                            property required

                                                                                                                                                                                                                                                                                                                                                                                            required?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                                                                                                              type: 'option';

                                                                                                                                                                                                                                                                                                                                                                                                namespace Hook

                                                                                                                                                                                                                                                                                                                                                                                                namespace Hook {}

                                                                                                                                                                                                                                                                                                                                                                                                  interface Context

                                                                                                                                                                                                                                                                                                                                                                                                  interface Context {}

                                                                                                                                                                                                                                                                                                                                                                                                    property config

                                                                                                                                                                                                                                                                                                                                                                                                    config: Config.IConfig;

                                                                                                                                                                                                                                                                                                                                                                                                      method debug

                                                                                                                                                                                                                                                                                                                                                                                                      debug: (...args: any[]) => void;

                                                                                                                                                                                                                                                                                                                                                                                                        method error

                                                                                                                                                                                                                                                                                                                                                                                                        error: (
                                                                                                                                                                                                                                                                                                                                                                                                        message: string | Error,
                                                                                                                                                                                                                                                                                                                                                                                                        options?: { code?: string; exit?: number }
                                                                                                                                                                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                          method exit

                                                                                                                                                                                                                                                                                                                                                                                                          exit: (code?: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                            method log

                                                                                                                                                                                                                                                                                                                                                                                                            log: (message?: any, ...args: any[]) => void;

                                                                                                                                                                                                                                                                                                                                                                                                              method warn

                                                                                                                                                                                                                                                                                                                                                                                                              warn: (message: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                type CommandNotFound

                                                                                                                                                                                                                                                                                                                                                                                                                type CommandNotFound = Hook<Hooks['command_not_found']>;

                                                                                                                                                                                                                                                                                                                                                                                                                  type Init

                                                                                                                                                                                                                                                                                                                                                                                                                  type Init = Hook<Hooks['init']>;

                                                                                                                                                                                                                                                                                                                                                                                                                    type PluginsPreinstall

                                                                                                                                                                                                                                                                                                                                                                                                                    type PluginsPreinstall = Hook<Hooks['plugins:preinstall']>;

                                                                                                                                                                                                                                                                                                                                                                                                                      type Postrun

                                                                                                                                                                                                                                                                                                                                                                                                                      type Postrun = Hook<Hooks['postrun']>;

                                                                                                                                                                                                                                                                                                                                                                                                                        type Prerun

                                                                                                                                                                                                                                                                                                                                                                                                                        type Prerun = Hook<Hooks['prerun']>;

                                                                                                                                                                                                                                                                                                                                                                                                                          type Preupdate

                                                                                                                                                                                                                                                                                                                                                                                                                          type Preupdate = Hook<Hooks['preupdate']>;

                                                                                                                                                                                                                                                                                                                                                                                                                            type Update

                                                                                                                                                                                                                                                                                                                                                                                                                            type Update = Hook<Hooks['update']>;

                                                                                                                                                                                                                                                                                                                                                                                                                              namespace IConfig

                                                                                                                                                                                                                                                                                                                                                                                                                              namespace IConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                namespace IConfig.s3Key

                                                                                                                                                                                                                                                                                                                                                                                                                                namespace IConfig.s3Key {}

                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Options

                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Options {}

                                                                                                                                                                                                                                                                                                                                                                                                                                    property arch

                                                                                                                                                                                                                                                                                                                                                                                                                                    arch?: ArchTypes;

                                                                                                                                                                                                                                                                                                                                                                                                                                      property platform

                                                                                                                                                                                                                                                                                                                                                                                                                                      platform?: PlatformTypes;

                                                                                                                                                                                                                                                                                                                                                                                                                                        index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                        [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                          namespace PJSON

                                                                                                                                                                                                                                                                                                                                                                                                                                          namespace PJSON {}

                                                                                                                                                                                                                                                                                                                                                                                                                                            interface CLI

                                                                                                                                                                                                                                                                                                                                                                                                                                            interface CLI extends Plugin {}

                                                                                                                                                                                                                                                                                                                                                                                                                                              property oclif

                                                                                                                                                                                                                                                                                                                                                                                                                                              oclif: Plugin['oclif'] & {
                                                                                                                                                                                                                                                                                                                                                                                                                                              schema?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                              bin?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                              npmRegistry?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                              scope?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                              dirname?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Plugin

                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Plugin extends PJSON {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                  name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property oclif

                                                                                                                                                                                                                                                                                                                                                                                                                                                    oclif: PJSON['oclif'] & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                    schema?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                    title?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                    description?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                    hooks?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                    [name: string]: string | string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                                                                                                                                                                                    commands?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                    plugins?: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                    devPlugins?: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                    helpClass?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                    aliases?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                    [name: string]: string | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                                                                                                                                                                                    repositoryPrefix?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                    update: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                    s3: S3;
                                                                                                                                                                                                                                                                                                                                                                                                                                                    autoupdate?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                    rollout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                    debounce?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                                                                                                                                                                                    node: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                    version?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                    targets?: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                                                                                                                                                                                    topics?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                    [k: string]: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                    description?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                    subtopics?: Plugin['oclif']['topics'];
                                                                                                                                                                                                                                                                                                                                                                                                                                                    hidden?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property version

                                                                                                                                                                                                                                                                                                                                                                                                                                                      version: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface S3

                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface S3 {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property acl

                                                                                                                                                                                                                                                                                                                                                                                                                                                          acl?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property bucket

                                                                                                                                                                                                                                                                                                                                                                                                                                                            bucket?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property gz

                                                                                                                                                                                                                                                                                                                                                                                                                                                              gz?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property host

                                                                                                                                                                                                                                                                                                                                                                                                                                                                host?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property templates

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  templates: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  target: S3.Templates;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  vanilla: S3.Templates;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property xz

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    xz?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface User

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface User extends PJSON {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property oclif

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        oclif: PJSON['oclif'] & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        plugins?: (string | PluginTypes.User | PluginTypes.Link)[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property private

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          private?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type PluginTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type PluginTypes =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | PluginTypes.User
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | PluginTypes.Link
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            root: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              namespace PJSON.PluginTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              namespace PJSON.PluginTypes {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Link {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property root

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    root: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type: 'link';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface User

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface User {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            tag?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type: 'user';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property url

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                url?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  namespace PJSON.S3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  namespace PJSON.S3 {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface Templates

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface Templates {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property baseDir

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      baseDir: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property manifest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        manifest: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property unversioned

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          unversioned: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property versioned

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            versioned: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Package Files (8)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Dependencies (6)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Dev Dependencies (18)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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/@oclif/config.

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