@prismer/sdk 2.0.8 → 2.2.55

package/node_modules/yargs/build/lib/validation.js

@@ -0,0 +1,330 @@
+"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', '--', '_'];
+// validation-type-stuff, missing params,
+// bad implications, custom checks.
+function validation(yargs, usage, y18n) {
+    const __ = y18n.__;
+    const __n = y18n.__n;
+    const self = {};
+    // validate appropriate # of non-option
+    // arguments were provided, i.e., '_'.
+    self.nonOptionCount = function nonOptionCount(argv) {
+        const demandedCommands = yargs.getDemandedCommands();
+        // don't count currently executing commands
+        const _s = argv._.length - yargs.getContext().commands.length;
+        if (demandedCommands._ && (_s < demandedCommands._.min || _s > demandedCommands._.max)) {
+            if (_s < demandedCommands._.min) {
+                if (demandedCommands._.minMsg !== undefined) {
+                    usage.fail(
+                    // replace $0 with observed, $1 with expected.
+                    demandedCommands._.minMsg
+                        ? demandedCommands._.minMsg.replace(/\$0/g, _s.toString()).replace(/\$1/, demandedCommands._.min.toString())
+                        : null);
+                }
+                else {
+                    usage.fail(__n('Not enough non-option arguments: got %s, need at least %s', 'Not enough non-option arguments: got %s, need at least %s', _s, _s, demandedCommands._.min));
+                }
+            }
+            else if (_s > demandedCommands._.max) {
+                if (demandedCommands._.maxMsg !== undefined) {
+                    usage.fail(
+                    // replace $0 with observed, $1 with expected.
+                    demandedCommands._.maxMsg
+                        ? demandedCommands._.maxMsg.replace(/\$0/g, _s.toString()).replace(/\$1/, demandedCommands._.max.toString())
+                        : null);
+                }
+                else {
+                    usage.fail(__n('Too many non-option arguments: got %s, maximum of %s', 'Too many non-option arguments: got %s, maximum of %s', _s, _s, demandedCommands._.max));
+                }
+            }
+        }
+    };
+    // validate the appropriate # of <required>
+    // positional arguments were provided:
+    self.positionalCount = function positionalCount(required, observed) {
+        if (observed < required) {
+            usage.fail(__n('Not enough non-option arguments: got %s, need at least %s', 'Not enough non-option arguments: got %s, need at least %s', observed, observed, required));
+        }
+    };
+    // make sure all the required arguments are present.
+    self.requiredArguments = function requiredArguments(argv) {
+        const demandedOptions = yargs.getDemandedOptions();
+        let missing = null;
+        for (const key of Object.keys(demandedOptions)) {
+            if (!Object.prototype.hasOwnProperty.call(argv, key) || typeof argv[key] === 'undefined') {
+                missing = missing || {};
+                missing[key] = demandedOptions[key];
+            }
+        }
+        if (missing) {
+            const customMsgs = [];
+            for (const key of Object.keys(missing)) {
+                const msg = missing[key];
+                if (msg && customMsgs.indexOf(msg) < 0) {
+                    customMsgs.push(msg);
+                }
+            }
+            const customMsg = customMsgs.length ? `\n${customMsgs.join('\n')}` : '';
+            usage.fail(__n('Missing required argument: %s', 'Missing required arguments: %s', Object.keys(missing).length, Object.keys(missing).join(', ') + customMsg));
+        }
+    };
+    // check for unknown arguments (strict-mode).
+    self.unknownArguments = function unknownArguments(argv, aliases, positionalMap, isDefaultCommand) {
+        const commandKeys = yargs.getCommandInstance().getCommands();
+        const unknown = [];
+        const currentContext = yargs.getContext();
+        Object.keys(argv).forEach((key) => {
+            if (specialKeys.indexOf(key) === -1 &&
+                !Object.prototype.hasOwnProperty.call(positionalMap, key) &&
+                !Object.prototype.hasOwnProperty.call(yargs._getParseContext(), key) &&
+                !self.isValidAndSomeAliasIsNotNew(key, aliases)) {
+                unknown.push(key);
+            }
+        });
+        if ((currentContext.commands.length > 0) || (commandKeys.length > 0) || isDefaultCommand) {
+            argv._.slice(currentContext.commands.length).forEach((key) => {
+                if (commandKeys.indexOf(key) === -1) {
+                    unknown.push(key);
+                }
+            });
+        }
+        if (unknown.length > 0) {
+            usage.fail(__n('Unknown argument: %s', 'Unknown arguments: %s', unknown.length, unknown.join(', ')));
+        }
+    };
+    self.unknownCommands = function unknownCommands(argv) {
+        const commandKeys = yargs.getCommandInstance().getCommands();
+        const unknown = [];
+        const currentContext = yargs.getContext();
+        if ((currentContext.commands.length > 0) || (commandKeys.length > 0)) {
+            argv._.slice(currentContext.commands.length).forEach((key) => {
+                if (commandKeys.indexOf(key) === -1) {
+                    unknown.push(key);
+                }
+            });
+        }
+        if (unknown.length > 0) {
+            usage.fail(__n('Unknown command: %s', 'Unknown commands: %s', unknown.length, unknown.join(', ')));
+            return true;
+        }
+        else {
+            return false;
+        }
+    };
+    // check for a key that is not an alias, or for which every alias is new,
+    // implying that it was invented by the parser, e.g., during camelization
+    self.isValidAndSomeAliasIsNotNew = function isValidAndSomeAliasIsNotNew(key, aliases) {
+        if (!Object.prototype.hasOwnProperty.call(aliases, key)) {
+            return false;
+        }
+        const newAliases = yargs.parsed.newAliases;
+        for (const a of [key, ...aliases[key]]) {
+            if (!Object.prototype.hasOwnProperty.call(newAliases, a) || !newAliases[key]) {
+                return true;
+            }
+        }
+        return false;
+    };
+    // validate arguments limited to enumerated choices
+    self.limitedChoices = function limitedChoices(argv) {
+        const options = yargs.getOptions();
+        const invalid = {};
+        if (!Object.keys(options.choices).length)
+            return;
+        Object.keys(argv).forEach((key) => {
+            if (specialKeys.indexOf(key) === -1 &&
+                Object.prototype.hasOwnProperty.call(options.choices, key)) {
+                [].concat(argv[key]).forEach((value) => {
+                    // TODO case-insensitive configurability
+                    if (options.choices[key].indexOf(value) === -1 &&
+                        value !== undefined) {
+                        invalid[key] = (invalid[key] || []).concat(value);
+                    }
+                });
+            }
+        });
+        const invalidKeys = Object.keys(invalid);
+        if (!invalidKeys.length)
+            return;
+        let msg = __('Invalid values:');
+        invalidKeys.forEach((key) => {
+            msg += `\n  ${__('Argument: %s, Given: %s, Choices: %s', key, usage.stringifiedValues(invalid[key]), usage.stringifiedValues(options.choices[key]))}`;
+        });
+        usage.fail(msg);
+    };
+    // custom checks, added using the `check` option on yargs.
+    let checks = [];
+    self.check = function check(f, global) {
+        checks.push({
+            func: f,
+            global
+        });
+    };
+    self.customChecks = function customChecks(argv, aliases) {
+        for (let i = 0, f; (f = checks[i]) !== undefined; i++) {
+            const func = f.func;
+            let result = null;
+            try {
+                result = func(argv, aliases);
+            }
+            catch (err) {
+                usage.fail(err.message ? err.message : err, err);
+                continue;
+            }
+            if (!result) {
+                usage.fail(__('Argument check failed: %s', func.toString()));
+            }
+            else if (typeof result === 'string' || result instanceof Error) {
+                usage.fail(result.toString(), result);
+            }
+        }
+    };
+    // check implications, argument foo implies => argument bar.
+    let implied = {};
+    self.implies = function implies(key, value) {
+        argsert_1.argsert('<string|object> [array|number|string]', [key, value], arguments.length);
+        if (typeof key === 'object') {
+            Object.keys(key).forEach((k) => {
+                self.implies(k, key[k]);
+            });
+        }
+        else {
+            yargs.global(key);
+            if (!implied[key]) {
+                implied[key] = [];
+            }
+            if (Array.isArray(value)) {
+                value.forEach((i) => self.implies(key, i));
+            }
+            else {
+                common_types_1.assertNotStrictEqual(value, undefined);
+                implied[key].push(value);
+            }
+        }
+    };
+    self.getImplied = function getImplied() {
+        return implied;
+    };
+    function keyExists(argv, val) {
+        // convert string '1' to number 1
+        const num = Number(val);
+        val = isNaN(num) ? val : num;
+        if (typeof val === 'number') {
+            // check length of argv._
+            val = argv._.length >= val;
+        }
+        else if (val.match(/^--no-.+/)) {
+            // check if key/value doesn't exist
+            val = val.match(/^--no-(.+)/)[1];
+            val = !argv[val];
+        }
+        else {
+            // check if key/value exists
+            val = argv[val];
+        }
+        return val;
+    }
+    self.implications = function implications(argv) {
+        const implyFail = [];
+        Object.keys(implied).forEach((key) => {
+            const origKey = key;
+            (implied[key] || []).forEach((value) => {
+                let key = origKey;
+                const origValue = value;
+                key = keyExists(argv, key);
+                value = keyExists(argv, value);
+                if (key && !value) {
+                    implyFail.push(` ${origKey} -> ${origValue}`);
+                }
+            });
+        });
+        if (implyFail.length) {
+            let msg = `${__('Implications failed:')}\n`;
+            implyFail.forEach((value) => {
+                msg += (value);
+            });
+            usage.fail(msg);
+        }
+    };
+    let conflicting = {};
+    self.conflicts = function conflicts(key, value) {
+        argsert_1.argsert('<string|object> [array|string]', [key, value], arguments.length);
+        if (typeof key === 'object') {
+            Object.keys(key).forEach((k) => {
+                self.conflicts(k, key[k]);
+            });
+        }
+        else {
+            yargs.global(key);
+            if (!conflicting[key]) {
+                conflicting[key] = [];
+            }
+            if (Array.isArray(value)) {
+                value.forEach((i) => self.conflicts(key, i));
+            }
+            else {
+                conflicting[key].push(value);
+            }
+        }
+    };
+    self.getConflicting = () => conflicting;
+    self.conflicting = function conflictingFn(argv) {
+        Object.keys(argv).forEach((key) => {
+            if (conflicting[key]) {
+                conflicting[key].forEach((value) => {
+                    // we default keys to 'undefined' that have been configured, we should not
+                    // apply conflicting check unless they are a value other than 'undefined'.
+                    if (value && argv[key] !== undefined && argv[value] !== undefined) {
+                        usage.fail(__('Arguments %s and %s are mutually exclusive', key, value));
+                    }
+                });
+            }
+        });
+    };
+    self.recommendCommands = function recommendCommands(cmd, potentialCommands) {
+        const threshold = 3; // if it takes more than three edits, let's move on.
+        potentialCommands = potentialCommands.sort((a, b) => b.length - a.length);
+        let recommended = null;
+        let bestDistance = Infinity;
+        for (let i = 0, candidate; (candidate = potentialCommands[i]) !== undefined; i++) {
+            const d = levenshtein_1.levenshtein(cmd, candidate);
+            if (d <= threshold && d < bestDistance) {
+                bestDistance = d;
+                recommended = candidate;
+            }
+        }
+        if (recommended)
+            usage.fail(__('Did you mean %s?', recommended));
+    };
+    self.reset = function reset(localLookup) {
+        implied = obj_filter_1.objFilter(implied, k => !localLookup[k]);
+        conflicting = obj_filter_1.objFilter(conflicting, k => !localLookup[k]);
+        checks = checks.filter(c => c.global);
+        return self;
+    };
+    const frozens = [];
+    self.freeze = function freeze() {
+        frozens.push({
+            implied,
+            checks,
+            conflicting
+        });
+    };
+    self.unfreeze = function unfreeze() {
+        const frozen = frozens.pop();
+        common_types_1.assertNotStrictEqual(frozen, undefined);
+        ({
+            implied,
+            checks,
+            conflicting
+        } = frozen);
+    };
+    return self;
+}
+exports.validation = validation;

package/node_modules/yargs/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 {};