yargs 15.3.2-beta.0 → 15.4.1

package/build/lib/completion.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const path = require("path");
+exports.completion = void 0;
+const command_1 = require("./command");
 const templates = require("./completion-templates");
 const is_promise_1 = require("./is-promise");
 const parse_command_1 = require("./parse-command");
-const type_helpers_1 = require("./type-helpers");
+const path = require("path");
+const common_types_1 = require("./common-types");
 // add bash completions to your
 //  yargs-powered applications.
 function completion(yargs, usage, command) {
@@ -26,8 +28,9 @@ function completion(yargs, usage, command) {
         const parentCommands = yargs.getContext().commands;
         // a custom completion function can be provided
         // to completion().
-        if (completionFunction) {
-            if (type_helpers_1.isSyncCompletionFunction(completionFunction)) {
+        function runCompletionFunction(argv) {
+            common_types_1.assertNotStrictEqual(completionFunction, null);
+            if (isSyncCompletionFunction(completionFunction)) {
                 const result = completionFunction(current, argv);
                 // promise based completion function.
                 if (is_promise_1.isPromise(result)) {
@@ -47,11 +50,14 @@ function completion(yargs, usage, command) {
                 });
             }
         }
+        if (completionFunction) {
+            return is_promise_1.isPromise(argv) ? argv.then(runCompletionFunction) : runCompletionFunction(argv);
+        }
         const handlers = command.getCommandHandlers();
         for (let i = 0, ii = args.length; i < ii; ++i) {
             if (handlers[args[i]] && handlers[args[i]].builder) {
                 const builder = handlers[args[i]].builder;
-                if (type_helpers_1.isFunctionCommandBuilder(builder)) {
+                if (command_1.isCommandBuilderCallback(builder)) {
                     const y = yargs.reset();
                     builder(y);
                     return y.argv;
@@ -124,3 +130,6 @@ function completion(yargs, usage, command) {
     return self;
 }
 exports.completion = completion;
+function isSyncCompletionFunction(completionFunction) {
+    return completionFunction.length < 3;
+}

package/build/lib/is-promise.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPromise = void 0;
 function isPromise(maybePromise) {
     return !!maybePromise &&
         !!maybePromise.then &&

package/build/lib/levenshtein.js

@@ -20,6 +20,7 @@ IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.levenshtein = void 0;
 // levenshtein distance algorithm, pulled from Andrei Mackenzie's MIT licensed.
 // gist, which can be found here: https://gist.github.com/andrei-m/982927
 // Compute the edit distance between the two given strings

package/build/lib/middleware.d.ts

@@ -0,0 +1,10 @@
+import { YargsInstance, Arguments } from './yargs';
+export declare function globalMiddlewareFactory<T>(globalMiddleware: Middleware[], context: T): (callback: MiddlewareCallback | MiddlewareCallback[], applyBeforeValidation?: boolean) => T;
+export declare function commandMiddlewareFactory(commandMiddleware?: MiddlewareCallback[]): Middleware[];
+export declare function applyMiddleware(argv: Arguments | Promise<Arguments>, yargs: YargsInstance, middlewares: Middleware[], beforeValidation: boolean): Arguments | Promise<Arguments>;
+export interface MiddlewareCallback {
+    (argv: Arguments, yargs: YargsInstance): Partial<Arguments> | Promise<Partial<Arguments>>;
+}
+export interface Middleware extends MiddlewareCallback {
+    applyBeforeValidation: boolean;
+}

package/build/lib/middleware.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyMiddleware = exports.commandMiddlewareFactory = exports.globalMiddlewareFactory = void 0;
+const argsert_1 = require("./argsert");
+const is_promise_1 = require("./is-promise");
+function globalMiddlewareFactory(globalMiddleware, context) {
+    return function (callback, applyBeforeValidation = false) {
+        argsert_1.argsert('<array|function> [boolean]', [callback, applyBeforeValidation], arguments.length);
+        if (Array.isArray(callback)) {
+            for (let i = 0; i < callback.length; i++) {
+                if (typeof callback[i] !== 'function') {
+                    throw Error('middleware must be a function');
+                }
+                callback[i].applyBeforeValidation = applyBeforeValidation;
+            }
+            Array.prototype.push.apply(globalMiddleware, callback);
+        }
+        else if (typeof callback === 'function') {
+            callback.applyBeforeValidation = applyBeforeValidation;
+            globalMiddleware.push(callback);
+        }
+        return context;
+    };
+}
+exports.globalMiddlewareFactory = globalMiddlewareFactory;
+function commandMiddlewareFactory(commandMiddleware) {
+    if (!commandMiddleware)
+        return [];
+    return commandMiddleware.map(middleware => {
+        middleware.applyBeforeValidation = false;
+        return middleware;
+    });
+}
+exports.commandMiddlewareFactory = commandMiddlewareFactory;
+function applyMiddleware(argv, yargs, middlewares, beforeValidation) {
+    const beforeValidationError = new Error('middleware cannot return a promise when applyBeforeValidation is true');
+    return middlewares
+        .reduce((acc, middleware) => {
+        if (middleware.applyBeforeValidation !== beforeValidation) {
+            return acc;
+        }
+        if (is_promise_1.isPromise(acc)) {
+            return acc
+                .then(initialObj => Promise.all([initialObj, middleware(initialObj, yargs)]))
+                .then(([initialObj, middlewareObj]) => Object.assign(initialObj, middlewareObj));
+        }
+        else {
+            const result = middleware(acc, yargs);
+            if (beforeValidation && is_promise_1.isPromise(result))
+                throw beforeValidationError;
+            return is_promise_1.isPromise(result)
+                ? result.then(middlewareObj => Object.assign(acc, middlewareObj))
+                : Object.assign(acc, result);
+        }
+    }, argv);
+}
+exports.applyMiddleware = applyMiddleware;

package/build/lib/obj-filter.d.ts

@@ -1,2 +1 @@
-import { Dictionary } from './types';
-export declare function objFilter<T = any>(original: Dictionary<T>, filter?: (k: string, v: T) => boolean): Dictionary<T>;
+export declare function objFilter<T extends object>(original?: T, filter?: (k: keyof T, v: T[keyof T]) => boolean): T;

package/build/lib/obj-filter.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-function objFilter(original, filter = () => true) {
+exports.objFilter = void 0;
+const common_types_1 = require("./common-types");
+function objFilter(original = {}, filter = () => true) {
     const obj = {};
-    Object.keys(original || {}).forEach((key) => {
+    common_types_1.objectKeys(original).forEach((key) => {
         if (filter(key, original[key])) {
             obj[key] = original[key];
         }

package/build/lib/parse-command.d.ts

@@ -1,2 +1,11 @@
-import { ParsedCommand } from './types';
+import { NotEmptyArray } from './common-types';
 export declare function parseCommand(cmd: string): ParsedCommand;
+export interface ParsedCommand {
+    cmd: string;
+    demanded: Positional[];
+    optional: Positional[];
+}
+export interface Positional {
+    cmd: NotEmptyArray<string>;
+    variadic: boolean;
+}

package/build/lib/parse-command.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCommand = void 0;
 function parseCommand(cmd) {
     const extraSpacesStrippedCommand = cmd.replace(/\s{2,}/g, ' ');
     const splitCommand = extraSpacesStrippedCommand.split(/\s+(?![^[]*]|[^<]*>)/);

package/build/lib/process-argv.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProcessArgvBin = exports.getProcessArgvWithoutBin = void 0;
 function getProcessArgvBinIndex() {
     // The binary name is the first command line argument for:
     // - bundled Electron apps: bin argv1 argv2 ... argvn

package/build/lib/usage.d.ts

@@ -1,3 +1,49 @@
-import { UsageInstance, YargsInstance } from './types';
-import Y18N = require('y18n');
+import { Dictionary } from './common-types';
+import { YargsInstance } from './yargs';
+import { YError } from './yerror';
+import { Y18N } from 'y18n';
 export declare function usage(yargs: YargsInstance, y18n: Y18N): UsageInstance;
+/** Instance of the usage module. */
+export interface UsageInstance {
+    cacheHelpMessage(): void;
+    clearCachedHelpMessage(): void;
+    command(cmd: string, description: string | undefined, isDefault: boolean, aliases: string[], deprecated?: boolean): void;
+    deferY18nLookup(str: string): string;
+    describe(keys: string | string[] | Dictionary<string>, desc?: string): void;
+    epilog(msg: string): void;
+    example(cmd: string, description?: string): void;
+    fail(msg?: string | null, err?: YError | string): void;
+    failFn(f: FailureFunction): void;
+    freeze(): void;
+    functionDescription(fn: {
+        name?: string;
+    }): string;
+    getCommands(): [string, string, boolean, string[], boolean][];
+    getDescriptions(): Dictionary<string | undefined>;
+    getPositionalGroupName(): string;
+    getUsage(): [string, string][];
+    getUsageDisabled(): boolean;
+    help(): string;
+    reset(localLookup: Dictionary<boolean>): UsageInstance;
+    showHelp(level: 'error' | 'log' | ((message: string) => void)): void;
+    showHelpOnFail(enabled?: boolean | string, message?: string): UsageInstance;
+    showVersion(): void;
+    stringifiedValues(values?: any[], separator?: string): string;
+    unfreeze(): void;
+    usage(msg: string | null, description?: string | false): UsageInstance;
+    version(ver: any): void;
+    wrap(cols: number | null | undefined): void;
+}
+export interface FailureFunction {
+    (msg: string | undefined | null, err: YError | string | undefined, usage: UsageInstance): void;
+}
+export interface FrozenUsageInstance {
+    failMessage: string | undefined | null;
+    failureOutput: boolean;
+    usages: [string, string][];
+    usageDisabled: boolean;
+    epilogs: string[];
+    examples: [string, string][];
+    commands: [string, string, boolean, string[], boolean][];
+    descriptions: Dictionary<string | undefined>;
+}

package/build/lib/usage.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.usage = void 0;
 // this file handles outputting usage instructions,
 // failures, etc. keeps logging in one place.
+const common_types_1 = require("./common-types");
 const obj_filter_1 = require("./obj-filter");
 const path = require("path");
 const yerror_1 = require("./yerror");
@@ -92,7 +94,7 @@ function usage(yargs, y18n) {
         examples.push([cmd, description || '']);
     };
     let commands = [];
-    self.command = function command(cmd, description, isDefault, aliases) {
+    self.command = function command(cmd, description, isDefault, aliases, deprecated = false) {
         // the last default wins, so cancel out any previously set default
         if (isDefault) {
             commands = commands.map((cmdArray) => {
@@ -100,12 +102,17 @@ function usage(yargs, y18n) {
                 return cmdArray;
             });
         }
-        commands.push([cmd, description || '', isDefault, aliases]);
+        commands.push([cmd, description || '', isDefault, aliases, deprecated]);
     };
     self.getCommands = () => commands;
     let descriptions = {};
     self.describe = function describe(keyOrKeys, desc) {
-        if (typeof keyOrKeys === 'object') {
+        if (Array.isArray(keyOrKeys)) {
+            keyOrKeys.forEach((k) => {
+                self.describe(k, desc);
+            });
+        }
+        else if (typeof keyOrKeys === 'object') {
             Object.keys(keyOrKeys).forEach((k) => {
                 self.describe(k, keyOrKeys[k]);
             });
@@ -207,6 +214,14 @@ function usage(yargs, y18n) {
                 if (command[3] && command[3].length) {
                     hints.push(`[${__('aliases:')} ${command[3].join(', ')}]`);
                 }
+                if (command[4]) {
+                    if (typeof command[4] === 'string') {
+                        hints.push(`[${__('deprecated: %s', command[4])}]`);
+                    }
+                    else {
+                        hints.push(`[${__('deprecated')}]`);
+                    }
+                }
                 if (hints.length) {
                     ui.div({ text: hints.join(' '), padding: [0, 0, 0, 2], align: 'right' });
                 }
@@ -508,8 +523,7 @@ function usage(yargs, y18n) {
     };
     self.unfreeze = function unfreeze() {
         const frozen = frozens.pop();
-        if (!frozen)
-            throw new Error('Nothing more to unfreeze');
+        common_types_1.assertNotStrictEqual(frozen, undefined);
         ({
             failMessage,
             failureOutput,

package/build/lib/validation.d.ts

@@ -1,3 +1,34 @@
-import { YargsInstance, UsageInstance, ValidationInstance } from './types';
-import Y18N = require('y18n');
+import { Dictionary } from './common-types';
+import { UsageInstance } from './usage';
+import { YargsInstance, Arguments } from './yargs';
+import { DetailedArguments } from 'yargs-parser';
+import { Y18N } from 'y18n';
 export declare function validation(yargs: YargsInstance, usage: UsageInstance, y18n: Y18N): ValidationInstance;
+/** Instance of the validation module. */
+export interface ValidationInstance {
+    check(f: CustomCheck['func'], global: boolean): void;
+    conflicting(argv: Arguments): void;
+    conflicts(key: string | Dictionary<string | string[]>, value?: string | string[]): void;
+    customChecks(argv: Arguments, aliases: DetailedArguments['aliases']): void;
+    freeze(): void;
+    getConflicting(): Dictionary<(string | undefined)[]>;
+    getImplied(): Dictionary<KeyOrPos[]>;
+    implications(argv: Arguments): void;
+    implies(key: string | Dictionary<KeyOrPos | KeyOrPos[]>, value?: KeyOrPos | KeyOrPos[]): void;
+    isValidAndSomeAliasIsNotNew(key: string, aliases: DetailedArguments['aliases']): boolean;
+    limitedChoices(argv: Arguments): void;
+    nonOptionCount(argv: Arguments): void;
+    positionalCount(required: number, observed: number): void;
+    recommendCommands(cmd: string, potentialCommands: string[]): void;
+    requiredArguments(argv: Arguments): void;
+    reset(localLookup: Dictionary): ValidationInstance;
+    unfreeze(): void;
+    unknownArguments(argv: Arguments, aliases: DetailedArguments['aliases'], positionalMap: Dictionary, isDefaultCommand: boolean): void;
+    unknownCommands(argv: Arguments): boolean;
+}
+interface CustomCheck {
+    func: (argv: Arguments, aliases: DetailedArguments['aliases']) => any;
+    global: boolean;
+}
+export declare type KeyOrPos = string | number;
+export {};

package/build/lib/validation.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.validation = void 0;
 const argsert_1 = require("./argsert");
+const common_types_1 = require("./common-types");
 const levenshtein_1 = require("./levenshtein");
 const obj_filter_1 = require("./obj-filter");
 const specialKeys = ['$0', '--', '_'];
@@ -73,7 +75,7 @@ function validation(yargs, usage, y18n) {
         }
     };
     // check for unknown arguments (strict-mode).
-    self.unknownArguments = function unknownArguments(argv, aliases, positionalMap) {
+    self.unknownArguments = function unknownArguments(argv, aliases, positionalMap, isDefaultCommand) {
         const commandKeys = yargs.getCommandInstance().getCommands();
         const unknown = [];
         const currentContext = yargs.getContext();
@@ -85,7 +87,7 @@ function validation(yargs, usage, y18n) {
                 unknown.push(key);
             }
         });
-        if ((currentContext.commands.length > 0) || (commandKeys.length > 0)) {
+        if ((currentContext.commands.length > 0) || (commandKeys.length > 0) || isDefaultCommand) {
             argv._.slice(currentContext.commands.length).forEach((key) => {
                 if (commandKeys.indexOf(key) === -1) {
                     unknown.push(key);
@@ -201,6 +203,7 @@ function validation(yargs, usage, y18n) {
                 value.forEach((i) => self.implies(key, i));
             }
             else {
+                common_types_1.assertNotStrictEqual(value, undefined);
                 implied[key].push(value);
             }
         }
@@ -315,8 +318,7 @@ function validation(yargs, usage, y18n) {
     };
     self.unfreeze = function unfreeze() {
         const frozen = frozens.pop();
-        if (!frozen)
-            throw new Error('Nothing more to unfreeze');
+        common_types_1.assertNotStrictEqual(frozen, undefined);
         ({
             implied,
             checks,

package/build/lib/yargs.d.ts

@@ -0,0 +1,274 @@
+/// <reference types="node" />
+import { CommandInstance, CommandHandler, CommandBuilderDefinition, CommandBuilder, CommandHandlerCallback, FinishCommandHandler } from './command';
+import { Dictionary } from './common-types';
+import { Arguments as ParserArguments, DetailedArguments as ParserDetailedArguments, Configuration as ParserConfiguration, Options as ParserOptions, ConfigCallback, CoerceCallback } from 'yargs-parser';
+import { YError } from './yerror';
+import { UsageInstance, FailureFunction } from './usage';
+import { CompletionFunction } from './completion';
+import { ValidationInstance, KeyOrPos } from './validation';
+import { Y18N } from 'y18n';
+import { MiddlewareCallback, Middleware } from './middleware';
+import { RequireDirectoryOptions } from 'require-directory';
+export declare function Yargs(processArgs?: string | string[], cwd?: string, parentRequire?: NodeRequire): YargsInstance;
+export declare function rebase(base: string, dir: string): string;
+/** Instance of the yargs module. */
+export interface YargsInstance {
+    $0: string;
+    argv: Arguments;
+    customScriptName: boolean;
+    parsed: DetailedArguments | false;
+    _copyDoubleDash<T extends Arguments | Promise<Arguments>>(argv: T): T;
+    _getLoggerInstance(): LoggerInstance;
+    _getParseContext(): Object;
+    _hasOutput(): boolean;
+    _hasParseCallback(): boolean;
+    _parseArgs: {
+        (args: null, shortCircuit: null, _calledFromCommand: boolean, commandIndex?: number): Arguments | Promise<Arguments>;
+        (args: string | string[], shortCircuit?: boolean): Arguments | Promise<Arguments>;
+    };
+    _runValidation(argv: Arguments, aliases: Dictionary<string[]>, positionalMap: Dictionary<string[]>, parseErrors: Error | null, isDefaultCommand?: boolean): void;
+    _setHasOutput(): void;
+    addHelpOpt: {
+        (opt?: string | false): YargsInstance;
+        (opt?: string, msg?: string): YargsInstance;
+    };
+    addShowHiddenOpt: {
+        (opt?: string | false): YargsInstance;
+        (opt?: string, msg?: string): YargsInstance;
+    };
+    alias: {
+        (keys: string | string[], aliases: string | string[]): YargsInstance;
+        (keyAliases: Dictionary<string | string[]>): YargsInstance;
+    };
+    array(keys: string | string[]): YargsInstance;
+    boolean(keys: string | string[]): YargsInstance;
+    check(f: (argv: Arguments, aliases: Dictionary<string[]>) => any, _global?: boolean): YargsInstance;
+    choices: {
+        (keys: string | string[], choices: string | string[]): YargsInstance;
+        (keyChoices: Dictionary<string | string[]>): YargsInstance;
+    };
+    coerce: {
+        (keys: string | string[], coerceCallback: CoerceCallback): YargsInstance;
+        (keyCoerceCallbacks: Dictionary<CoerceCallback>): YargsInstance;
+    };
+    command(cmd: string | string[], description: CommandHandler['description'], builder?: CommandBuilderDefinition | CommandBuilder, handler?: CommandHandlerCallback, commandMiddleware?: Middleware[], deprecated?: boolean): YargsInstance;
+    commandDir(dir: string, opts?: RequireDirectoryOptions<any>): YargsInstance;
+    completion: {
+        (cmd?: string, fn?: CompletionFunction): YargsInstance;
+        (cmd?: string, desc?: string | false, fn?: CompletionFunction): YargsInstance;
+    };
+    config: {
+        (config: Dictionary): YargsInstance;
+        (keys?: string | string[], configCallback?: ConfigCallback): YargsInstance;
+        (keys?: string | string[], msg?: string, configCallback?: ConfigCallback): YargsInstance;
+    };
+    conflicts: {
+        (key: string, conflictsWith: string | string[]): YargsInstance;
+        (keyConflicts: Dictionary<string | string[]>): YargsInstance;
+    };
+    count(keys: string | string[]): YargsInstance;
+    default: {
+        (key: string, value: any, defaultDescription?: string): YargsInstance;
+        (keys: string[], value: Exclude<any, Function>): YargsInstance;
+        (keys: Dictionary<any>): YargsInstance;
+    };
+    defaults: YargsInstance['default'];
+    demand: {
+        (min: number, max?: number | string, msg?: string): YargsInstance;
+        (keys: string | string[], msg?: string | true): YargsInstance;
+        (keys: string | string[], max: string[], msg?: string | true): YargsInstance;
+        (keyMsgs: Dictionary<string | undefined>): YargsInstance;
+        (keyMsgs: Dictionary<string | undefined>, max: string[], msg?: string): YargsInstance;
+    };
+    demandCommand(): YargsInstance;
+    demandCommand(min: number, minMsg?: string): YargsInstance;
+    demandCommand(min: number, max: number, minMsg?: string | null, maxMsg?: string | null): YargsInstance;
+    demandOption: {
+        (keys: string | string[], msg?: string): YargsInstance;
+        (keyMsgs: Dictionary<string | undefined>): YargsInstance;
+    };
+    deprecateOption(option: string, message?: string | boolean): YargsInstance;
+    describe: {
+        (keys: string | string[], description?: string): YargsInstance;
+        (keyDescriptions: Dictionary<string>): YargsInstance;
+    };
+    detectLocale(detect: boolean): YargsInstance;
+    env(prefix?: string | false): YargsInstance;
+    epilog: YargsInstance['epilogue'];
+    epilogue(msg: string): YargsInstance;
+    example(cmd: string | [string, string?][], description?: string): YargsInstance;
+    exit(code: number, err?: YError | string): void;
+    exitProcess(enabled: boolean): YargsInstance;
+    fail(f: FailureFunction): YargsInstance;
+    getCommandInstance(): CommandInstance;
+    getCompletion(args: string[], done: (completions: string[]) => any): void;
+    getContext(): Context;
+    getDemandedCommands(): Options['demandedCommands'];
+    getDemandedOptions(): Options['demandedOptions'];
+    getDeprecatedOptions(): Options['deprecatedOptions'];
+    getDetectLocale(): boolean;
+    getExitProcess(): boolean;
+    getGroups(): Dictionary<string[]>;
+    getHandlerFinishCommand(): FinishCommandHandler | null;
+    getOptions(): Options;
+    getParserConfiguration(): Configuration;
+    getStrict(): boolean;
+    getStrictCommands(): boolean;
+    getUsageInstance(): UsageInstance;
+    getValidationInstance(): ValidationInstance;
+    global(keys: string | string[], global?: boolean): YargsInstance;
+    group(keys: string | string[], groupName: string): YargsInstance;
+    help: YargsInstance['addHelpOpt'];
+    hide(key: string): YargsInstance;
+    implies: {
+        (key: string, implication: KeyOrPos | KeyOrPos[]): YargsInstance;
+        (keyImplications: Dictionary<KeyOrPos | KeyOrPos[]>): YargsInstance;
+    };
+    locale: {
+        (): string;
+        (locale: string): YargsInstance;
+    };
+    middleware(callback: MiddlewareCallback | MiddlewareCallback[], applyBeforeValidation?: boolean): YargsInstance;
+    nargs: {
+        (keys: string | string[], nargs: number): YargsInstance;
+        (keyNargs: Dictionary<number>): YargsInstance;
+    };
+    normalize(keys: string | string[]): YargsInstance;
+    number(keys: string | string[]): YargsInstance;
+    onFinishCommand(f: FinishCommandHandler): YargsInstance;
+    option: {
+        (key: string, optionDefinition: OptionDefinition): YargsInstance;
+        (keyOptionDefinitions: Dictionary<OptionDefinition>): YargsInstance;
+    };
+    options: YargsInstance['option'];
+    parse: {
+        (): Arguments | Promise<Arguments>;
+        (args: string | string[], context: object, parseCallback?: ParseCallback): Arguments | Promise<Arguments>;
+        (args: string | string[], parseCallback: ParseCallback): Arguments | Promise<Arguments>;
+        (args: string | string[], shortCircuit: boolean): Arguments | Promise<Arguments>;
+    };
+    parserConfiguration(config: Configuration): YargsInstance;
+    pkgConf(key: string, rootPath?: string): YargsInstance;
+    positional(key: string, positionalDefinition: PositionalDefinition): YargsInstance;
+    recommendCommands(recommend: boolean): YargsInstance;
+    require: YargsInstance['demand'];
+    required: YargsInstance['demand'];
+    requiresArg(keys: string | string[] | Dictionary): YargsInstance;
+    reset(aliases?: DetailedArguments['aliases']): YargsInstance;
+    resetOptions(aliases?: DetailedArguments['aliases']): YargsInstance;
+    scriptName(scriptName: string): YargsInstance;
+    showCompletionScript($0?: string, cmd?: string): YargsInstance;
+    showHelp(level: 'error' | 'log' | ((message: string) => void)): YargsInstance;
+    showHelpOnFail: {
+        (message?: string): YargsInstance;
+        (enabled: boolean, message: string): YargsInstance;
+    };
+    showHidden: YargsInstance['addShowHiddenOpt'];
+    skipValidation(keys: string | string[]): YargsInstance;
+    strict(enable?: boolean): YargsInstance;
+    strictCommands(enable?: boolean): YargsInstance;
+    string(key: string | string[]): YargsInstance;
+    terminalWidth(): number | null;
+    updateStrings(obj: Dictionary<string>): YargsInstance;
+    updateLocale: YargsInstance['updateStrings'];
+    usage: {
+        (msg: string | null): YargsInstance;
+        (msg: string, description: CommandHandler['description'], builder?: CommandBuilderDefinition | CommandBuilder, handler?: CommandHandlerCallback): YargsInstance;
+    };
+    version: {
+        (ver?: string | false): YargsInstance;
+        (key?: string, ver?: string): YargsInstance;
+        (key?: string, msg?: string, ver?: string): YargsInstance;
+    };
+    wrap(cols: number | null | undefined): YargsInstance;
+}
+export declare function isYargsInstance(y: YargsInstance | void): y is YargsInstance;
+/** Yargs' context. */
+export interface Context {
+    commands: string[];
+    files: string[];
+    fullCommands: string[];
+}
+declare type LoggerInstance = Pick<Console, 'error' | 'log'>;
+export interface Options extends ParserOptions {
+    __: Y18N['__'];
+    alias: Dictionary<string[]>;
+    array: string[];
+    boolean: string[];
+    choices: Dictionary<string[]>;
+    config: Dictionary<ConfigCallback | boolean>;
+    configObjects: Dictionary[];
+    configuration: Configuration;
+    count: string[];
+    defaultDescription: Dictionary<string | undefined>;
+    demandedCommands: Dictionary<{
+        min: number;
+        max: number;
+        minMsg?: string | null;
+        maxMsg?: string | null;
+    }>;
+    demandedOptions: Dictionary<string | undefined>;
+    deprecatedOptions: Dictionary<string | boolean | undefined>;
+    hiddenOptions: string[];
+    /** Manually set keys */
+    key: Dictionary<boolean | string>;
+    local: string[];
+    normalize: string[];
+    number: string[];
+    showHiddenOpt: string;
+    skipValidation: string[];
+    string: string[];
+}
+export interface Configuration extends Partial<ParserConfiguration> {
+    /** Should a config object be deep-merged with the object config it extends? */
+    'deep-merge-config'?: boolean;
+    /** Should commands be sorted in help? */
+    'sort-commands'?: boolean;
+}
+export interface OptionDefinition {
+    alias?: string | string[];
+    array?: boolean;
+    boolean?: boolean;
+    choices?: string | string[];
+    coerce?: CoerceCallback;
+    config?: boolean;
+    configParser?: ConfigCallback;
+    conflicts?: string | string[];
+    count?: boolean;
+    default?: any;
+    defaultDescription?: string;
+    deprecate?: string | boolean;
+    deprecated?: OptionDefinition['deprecate'];
+    desc?: string;
+    describe?: OptionDefinition['desc'];
+    description?: OptionDefinition['desc'];
+    demand?: string | true;
+    demandOption?: OptionDefinition['demand'];
+    global?: boolean;
+    group?: string;
+    hidden?: boolean;
+    implies?: string | number | KeyOrPos[];
+    nargs?: number;
+    normalize?: boolean;
+    number?: boolean;
+    require?: OptionDefinition['demand'];
+    required?: OptionDefinition['demand'];
+    requiresArg?: boolean;
+    skipValidation?: boolean;
+    string?: boolean;
+    type?: 'array' | 'boolean' | 'count' | 'number' | 'string';
+}
+interface PositionalDefinition extends Pick<OptionDefinition, 'alias' | 'array' | 'coerce' | 'choices' | 'conflicts' | 'default' | 'defaultDescription' | 'demand' | 'desc' | 'describe' | 'description' | 'implies' | 'normalize'> {
+    type?: 'boolean' | 'number' | 'string';
+}
+interface ParseCallback {
+    (err: YError | string | undefined | null, argv: Arguments | Promise<Arguments>, output: string): void;
+}
+export interface Arguments extends ParserArguments {
+    /** The script name or node command */
+    $0: string;
+}
+export interface DetailedArguments extends ParserDetailedArguments {
+    argv: Arguments;
+}
+export {};