@walkhi/code-relax 0.1.0-beta.4 → 0.1.0-beta.40

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

@@ -1,330 +0,0 @@
-"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

@@ -1,274 +0,0 @@
-/// <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 {};