@oclif/core 2.0.0-beta.3 → 2.0.0-beta.5

package/lib/command.js

@@ -1,14 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Command = void 0;
 const url_1 = require("url");
+const chalk = require("chalk");
 const util_1 = require("util");
-const index_1 = require("./index");
+const ux = require("./cli-ux");
 const config_1 = require("./config");
 const Errors = require("./errors");
 const Parser = require("./parser");
-const Flags = require("./flags");
 const util_2 = require("./help/util");
-const pjson = require('../package.json');
+const flags_1 = require("./flags");
+const util_3 = require("./util");
+const pjson = (0, util_3.requireJson)(__dirname, '..', 'package.json');
 /**
  * swallows stdout epipe errors
  * this occurs when stdout closes such as when piping to head
@@ -19,7 +22,7 @@ process.stdout.on('error', (err) => {
     throw err;
 });
 const jsonFlag = {
-    json: Flags.boolean({
+    json: (0, flags_1.boolean)({
         description: 'Format output as json.',
         helpGroup: 'GLOBAL',
     }),
@@ -35,26 +38,45 @@ class Command {
     static set enableJsonFlag(value) {
         this._enableJsonFlag = value;
         if (value === true) {
-            this.globalFlags = jsonFlag;
+            this.baseFlags = jsonFlag;
         }
         else {
-            delete this.globalFlags?.json;
+            delete this.baseFlags?.json;
             this.flags = {}; // force the flags setter to run
             delete this.flags?.json;
         }
     }
-    static get globalFlags() {
-        return this._globalFlags;
-    }
-    static set globalFlags(flags) {
-        this._globalFlags = Object.assign({}, this.globalFlags, flags);
+    /**
+     * instantiate and run the command
+     *
+     * @param {Command.Class} this - the command class
+     * @param {string[]} argv argv
+     * @param {LoadOptions} opts options
+     * @returns {Promise<unknown>} result
+     */
+    static async run(argv, opts) {
+        if (!argv)
+            argv = process.argv.slice(2);
+        // Handle the case when a file URL string is passed in such as 'import.meta.url'; covert to file path.
+        if (typeof opts === 'string' && opts.startsWith('file://')) {
+            opts = (0, url_1.fileURLToPath)(opts);
+        }
+        const config = await config_1.Config.load(opts || require.main?.filename || __dirname);
+        const cmd = new this(argv, config);
+        return cmd._run();
+    }
+    static get baseFlags() {
+        return this._baseFlags;
+    }
+    static set baseFlags(flags) {
+        this._baseFlags = Object.assign({}, this.baseFlags, flags);
         this.flags = {}; // force the flags setter to run
     }
     static get flags() {
         return this._flags;
     }
     static set flags(flags) {
-        this._flags = Object.assign({}, this._flags ?? {}, this.globalFlags, flags);
+        this._flags = Object.assign({}, this._flags ?? {}, this.baseFlags, flags);
     }
     constructor(argv, config) {
         this.argv = argv;
@@ -87,7 +109,7 @@ class Command {
             await this.finally(err);
         }
         if (result && this.jsonEnabled()) {
-            index_1.CliUx.ux.styledJSON(this.toSuccessJson(result));
+            ux.styledJSON(this.toSuccessJson(result));
         }
         return result;
     }
@@ -137,7 +159,7 @@ class Command {
             const deprecateAliases = this.ctor.flags[flag]?.deprecateAliases;
             const aliases = (this.ctor.flags[flag]?.aliases ?? []).map(a => a.length === 1 ? `-${a}` : `--${a}`);
             if (deprecateAliases && aliases.length > 0) {
-                const foundAliases = this.argv.filter(a => aliases.includes(a));
+                const foundAliases = aliases.filter(alias => this.argv.some(a => a.startsWith(alias)));
                 for (const alias of foundAliases) {
                     this.warn((0, util_2.formatFlagDeprecationWarning)(alias, { to: this.ctor.flags[flag]?.name }));
                 }
@@ -147,18 +169,18 @@ class Command {
     warnIfCommandDeprecated() {
         const [id] = (0, util_2.normalizeArgv)(this.config);
         if (this.ctor.deprecateAliases && this.ctor.aliases.includes(id)) {
-            const cmdName = (0, index_1.toConfiguredId)(this.ctor.id, this.config);
-            const aliasName = (0, index_1.toConfiguredId)(id, this.config);
+            const cmdName = (0, util_2.toConfiguredId)(this.ctor.id, this.config);
+            const aliasName = (0, util_2.toConfiguredId)(id, this.config);
             this.warn((0, util_2.formatCommandDeprecationWarning)(aliasName, { to: cmdName }));
         }
         if (this.ctor.state === 'deprecated') {
-            const cmdName = (0, index_1.toConfiguredId)(this.ctor.id, this.config);
+            const cmdName = (0, util_2.toConfiguredId)(this.ctor.id, this.config);
             this.warn((0, util_2.formatCommandDeprecationWarning)(cmdName, this.ctor.deprecationOptions));
         }
     }
     async parse(options, argv = this.argv) {
         if (!options)
-            options = this.constructor;
+            options = this.ctor;
         const opts = { context: this, ...options };
         // the spread operator doesn't work with getters so we have to manually add it here
         opts.flags = options?.flags;
@@ -170,14 +192,13 @@ class Command {
     async catch(err) {
         process.exitCode = process.exitCode ?? err.exitCode ?? 1;
         if (this.jsonEnabled()) {
-            index_1.CliUx.ux.styledJSON(this.toErrorJson(err));
+            ux.styledJSON(this.toErrorJson(err));
         }
         else {
             if (!err.message)
                 throw err;
             try {
-                const chalk = require('chalk');
-                index_1.CliUx.ux.action.stop(chalk.bold.red('!'));
+                ux.action.stop(chalk.bold.red('!'));
             }
             catch { }
             throw err;
@@ -200,31 +221,13 @@ class Command {
         return { error: err };
     }
 }
-exports.default = Command;
+exports.Command = Command;
 Command._base = `${pjson.name}@${pjson.version}`;
 /** An array of aliases for this command. */
 Command.aliases = [];
 /** When set to false, allows a variable amount of arguments */
 Command.strict = true;
-Command.parse = true;
-Command.parserOptions = {};
+/** An order-dependent object of arguments for the command */
+Command.args = {};
+Command.hasDynamicHelp = false;
 Command._enableJsonFlag = false;
-// eslint-disable-next-line valid-jsdoc
-/**
- * instantiate and run the command
- * @param {Interfaces.Command.Class} this Class
- * @param {string[]} argv argv
- * @param {Interfaces.LoadOptions} opts options
- */
-Command.run = async function (argv, opts) {
-    if (!argv)
-        argv = process.argv.slice(2);
-    // Handle the case when a file URL string is passed in such as 'import.meta.url'; covert to file path.
-    if (typeof opts === 'string' && opts.startsWith('file://')) {
-        opts = (0, url_1.fileURLToPath)(opts);
-    }
-    // to-do: update in node-14 to module.main
-    const config = await config_1.Config.load(opts || (module.parent && module.parent.parent && module.parent.parent.filename) || __dirname);
-    const cmd = new this(argv, config);
-    return cmd._run(argv);
-};

package/lib/config/config.d.ts

@@ -1,35 +1,36 @@
 import { Options, Plugin as IPlugin } from '../interfaces/plugin';
 import { Config as IConfig, ArchTypes, PlatformTypes, LoadOptions } from '../interfaces/config';
-import { Command, Hook, Hooks, PJSON, Topic } from '../interfaces';
+import { Hook, Hooks, PJSON, Topic } from '../interfaces';
 import * as Plugin from './plugin';
+import { Command } from '../command';
 export declare class Config implements IConfig {
     options: Options;
-    _base: string;
-    name: string;
-    version: string;
-    channel: string;
-    root: string;
+    private _base;
     arch: ArchTypes;
     bin: string;
+    binPath?: string;
     cacheDir: string;
+    channel: string;
     configDir: string;
     dataDir: string;
+    debug: number;
     dirname: string;
     errlog: string;
+    flexibleTaxonomy: boolean;
     home: string;
+    name: string;
+    npmRegistry?: string;
+    pjson: PJSON.CLI;
     platform: PlatformTypes;
+    plugins: IPlugin[];
+    root: string;
     shell: string;
-    windows: boolean;
+    topicSeparator: ':' | ' ';
     userAgent: string;
-    debug: number;
-    npmRegistry?: string;
-    pjson: PJSON.CLI;
     userPJSON?: PJSON.User;
-    plugins: IPlugin[];
-    binPath?: string;
     valid: boolean;
-    topicSeparator: ':' | ' ';
-    flexibleTaxonomy: boolean;
+    version: string;
+    windows: boolean;
     protected warned: boolean;
     private commandPermutations;
     private topicPermutations;
@@ -37,13 +38,13 @@ export declare class Config implements IConfig {
     private _topics;
     private _commandIDs;
     constructor(options: Options);
-    static load(opts?: LoadOptions): Promise<IConfig | Config>;
+    static load(opts?: LoadOptions): Promise<Config>;
     load(): Promise<void>;
     loadCorePlugins(): Promise<void>;
     loadDevPlugins(): Promise<void>;
     loadUserPlugins(): Promise<void>;
     runHook<T extends keyof Hooks>(event: T, opts: Hooks[T]['options'], timeout?: number): Promise<Hook.Result<Hooks[T]['return']>>;
-    runCommand<T = unknown>(id: string, argv?: string[], cachedCommand?: Command.Loadable): Promise<T>;
+    runCommand<T = unknown>(id: string, argv?: string[], cachedCommand?: Command.Loadable | null): Promise<T>;
     scopedEnvVar(k: string): string | undefined;
     scopedEnvVarTrue(k: string): boolean;
     scopedEnvVarKey(k: string): string;
@@ -130,4 +131,4 @@ export declare class Config implements IConfig {
      */
     private determinePriority;
 }
-export declare function toCached(c: Command.Class, plugin?: IPlugin): Promise<Command>;
+export declare function toCached(c: Command.Class, plugin?: IPlugin): Promise<Command.Cached>;

package/lib/config/config.js

@@ -14,7 +14,7 @@ const module_loader_1 = require("../module-loader");
 const util_4 = require("../help/util");
 // eslint-disable-next-line new-cap
 const debug = (0, util_2.Debug)();
-const _pjson = require('../../package.json');
+const _pjson = (0, util_3.requireJson)(__dirname, '..', '..', 'package.json');
 function channelFromVersion(version) {
     const m = version.match(/[^-]+(?:-([^.]+))?/);
     return (m && m[1]) || 'stable';
@@ -53,7 +53,6 @@ class Permutations extends Map {
     }
 }
 class Config {
-    // eslint-disable-next-line no-useless-constructor
     constructor(options) {
         this.options = options;
         this._base = `${_pjson.name}@${_pjson.version}`;
@@ -66,7 +65,7 @@ class Config {
         this._commands = new Map();
         this._topics = new Map();
     }
-    static async load(opts = (module.parent && module.parent.parent && module.parent.parent.filename) || __dirname) {
+    static async load(opts = module.filename || __dirname) {
         // Handle the case when a file URL string is passed in such as 'import.meta.url'; covert to file path.
         if (typeof opts === 'string' && opts.startsWith('file://')) {
             opts = (0, url_1.fileURLToPath)(opts);
@@ -249,10 +248,9 @@ class Config {
         debug('%s hook done', event);
         return final;
     }
-    // eslint-disable-next-line default-param-last
-    async runCommand(id, argv = [], cachedCommand) {
+    async runCommand(id, argv = [], cachedCommand = null) {
         debug('runCommand %s %o', id, argv);
-        const c = cachedCommand || this.findCommand(id);
+        const c = cachedCommand ?? this.findCommand(id);
         if (!c) {
             const matches = this.flexibleTaxonomy ? this.findMatches(id, argv) : [];
             const hookResult = this.flexibleTaxonomy && matches.length > 0 ?
@@ -270,7 +268,7 @@ class Config {
         const command = await c.load();
         await this.runHook('prerun', { Command: command, argv });
         const result = (await command.run(argv, this));
-        await this.runHook('postrun', { Command: command, result: result, argv });
+        await this.runHook('postrun', { Command: command, result, argv });
         return result;
     }
     scopedEnvVar(k) {
@@ -605,7 +603,7 @@ class Config {
 }
 exports.Config = Config;
 // when no manifest exists, the default is calculated.  This may throw, so we need to catch it
-const defaultToCached = async (flag) => {
+const defaultFlagToCached = async (flag) => {
     // Prefer the helpDefaultValue function (returns a friendly string for complex types)
     if (typeof flag.defaultHelp === 'function') {
         try {
@@ -626,6 +624,27 @@ const defaultToCached = async (flag) => {
         return flag.default;
     }
 };
+const defaultArgToCached = async (arg) => {
+    // Prefer the helpDefaultValue function (returns a friendly string for complex types)
+    if (typeof arg.defaultHelp === 'function') {
+        try {
+            return await arg.defaultHelp();
+        }
+        catch {
+            return;
+        }
+    }
+    // if not specified, try the default function
+    if (typeof arg.default === 'function') {
+        try {
+            return await arg.default({ options: {}, flags: {} });
+        }
+        catch { }
+    }
+    else {
+        return arg.default;
+    }
+};
 async function toCached(c, plugin) {
     const flags = {};
     for (const [name, flag] of Object.entries(c.flags || {})) {
@@ -647,6 +666,7 @@ async function toCached(c, plugin) {
                 deprecated: flag.deprecated,
                 deprecateAliases: c.deprecateAliases,
                 aliases: flag.aliases,
+                delimiter: flag.delimiter,
             };
         }
         else {
@@ -666,10 +686,11 @@ async function toCached(c, plugin) {
                 dependsOn: flag.dependsOn,
                 relationships: flag.relationships,
                 exclusive: flag.exclusive,
-                default: await defaultToCached(flag),
+                default: await defaultFlagToCached(flag),
                 deprecated: flag.deprecated,
                 deprecateAliases: c.deprecateAliases,
                 aliases: flag.aliases,
+                delimiter: flag.delimiter,
             };
             // a command-level placeholder in the manifest so that oclif knows it should regenerate the command during help-time
             if (typeof flag.defaultHelp === 'function') {
@@ -677,17 +698,21 @@ async function toCached(c, plugin) {
             }
         }
     }
-    // v2 commands have args as an object, so we need to normalize it to an array for forwards compatibility
-    const normalized = (Array.isArray(c.args) ? c.args ?? [] : Object.values(c.args ?? {}));
-    const argsPromise = normalized.map(async (a) => ({
-        name: a.name,
-        description: a.description,
-        required: a.required,
-        options: a.options,
-        default: typeof a.default === 'function' ? await a.default({}) : a.default,
-        hidden: a.hidden,
-    }));
-    const args = await Promise.all(argsPromise);
+    // v1 commands have args as an array, so we need to normalize it to an object for backwards compatibility
+    const normalized = (Array.isArray(c.args) ? (c.args ?? []).reduce((x, y) => {
+        return { ...x, [y.name]: y };
+    }, {}) : c.args ?? {});
+    const args = {};
+    for (const [name, arg] of Object.entries(normalized)) {
+        args[name] = {
+            name,
+            description: arg.description,
+            required: arg.required,
+            options: arg.options,
+            default: await defaultArgToCached(arg),
+            hidden: arg.hidden,
+        };
+    }
     const stdProperties = {
         id: c.id,
         summary: c.summary,
@@ -706,8 +731,7 @@ async function toCached(c, plugin) {
         flags,
         args,
     };
-    // do not include these properties in manifest
-    const ignoreCommandProperties = ['plugin', '_flags', '_enableJsonFlag', '_globalFlags'];
+    const ignoreCommandProperties = ['plugin', '_flags', '_enableJsonFlag', '_baseFlags'];
     const stdKeys = Object.keys(stdProperties);
     const keysToAdd = Object.keys(c).filter(property => ![...stdKeys, ...ignoreCommandProperties].includes(property));
     const additionalProperties = {};

package/lib/config/index.js

@@ -1,11 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tsPath = exports.Plugin = exports.toCached = exports.Config = void 0;
-try {
-    // eslint-disable-next-line node/no-missing-require
-    require('fs-extra-debug');
-}
-catch { }
 var config_1 = require("./config");
 Object.defineProperty(exports, "Config", { enumerable: true, get: function () { return config_1.Config; } });
 Object.defineProperty(exports, "toCached", { enumerable: true, get: function () { return config_1.toCached; } });

package/lib/config/plugin.d.ts

@@ -1,8 +1,9 @@
+import { CLIError } from '../errors';
 import { Plugin as IPlugin, PluginOptions } from '../interfaces/plugin';
-import { Command } from '../interfaces/command';
 import { Manifest } from '../interfaces/manifest';
 import { PJSON } from '../interfaces/pjson';
 import { Topic } from '../interfaces/topic';
+import { Command } from '../command';
 export declare class Plugin implements IPlugin {
     options: PluginOptions;
     _base: string;
@@ -36,6 +37,6 @@ export declare class Plugin implements IPlugin {
         must: boolean;
     }): Promise<Command.Class | undefined>;
     protected _manifest(ignoreManifest: boolean, errorOnManifestCreate?: boolean): Promise<Manifest>;
-    protected warn(err: any, scope?: string): void;
+    protected warn(err: string | Error | CLIError, scope?: string): void;
     private addErrorScope;
 }

package/lib/config/plugin.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Plugin = void 0;
 const errors_1 = require("../errors");
+const globby = require("globby");
 const path = require("path");
 const util_1 = require("util");
 const config_1 = require("./config");
@@ -10,17 +11,17 @@ const ts_node_1 = require("./ts-node");
 const util_3 = require("./util");
 const util_4 = require("../util");
 const module_loader_1 = require("../module-loader");
-const _pjson = require('../../package.json');
+const _pjson = (0, util_4.requireJson)(__dirname, '..', '..', 'package.json');
 function topicsToArray(input, base) {
     if (!input)
         return [];
     base = base ? `${base}:` : '';
     if (Array.isArray(input)) {
-        return input.concat((0, util_3.flatMap)(input, t => topicsToArray(t.subtopics, `${base}${t.name}`)));
+        return [...input, ...(0, util_3.flatMap)(input, t => topicsToArray(t.subtopics, `${base}${t.name}`))];
     }
     return (0, util_3.flatMap)(Object.keys(input), k => {
         input[k].name = k;
-        return [{ ...input[k], name: `${base}${k}` }].concat(topicsToArray(input[k].subtopics, `${base}${input[k].name}`));
+        return [{ ...input[k], name: `${base}${k}` }, ...topicsToArray(input[k].subtopics, `${base}${input[k].name}`)];
     });
 }
 // essentially just "cd .."
@@ -86,7 +87,6 @@ async function findRoot(name, root) {
     return findSourcesRoot(root);
 }
 class Plugin {
-    // eslint-disable-next-line no-useless-constructor
     constructor(options) {
         this.options = options;
         // static loadedPlugins: {[name: string]: Plugin} = {}
@@ -139,15 +139,6 @@ class Plugin {
     get commandIDs() {
         if (!this.commandsDir)
             return [];
-        let globby;
-        try {
-            const globbyPath = require.resolve('globby', { paths: [this.root, __dirname] });
-            globby = require(globbyPath);
-        }
-        catch (error) {
-            this.warn(error, 'not loading commands, globby not found');
-            return [];
-        }
         this._debug(`loading IDs from ${this.commandsDir}`);
         const patterns = [
             '**/*.+(js|cjs|mjs|ts|tsx)',

package/lib/config/util.js

@@ -4,7 +4,7 @@ exports.collectUsableIds = exports.getCommandIdPermutations = exports.getPermuta
 const fs = require("fs");
 const debug = require('debug');
 function flatMap(arr, fn) {
-    return arr.reduce((arr, i) => arr.concat(fn(i)), []);
+    return arr.reduce((arr, i) => [...arr, ...fn(i)], []);
 }
 exports.flatMap = flatMap;
 function mapValues(obj, fn) {
@@ -81,7 +81,7 @@ function getPermutations(arr) {
         for (let j = 0, len2 = partial.length; j <= len2; j++) {
             const start = partial.slice(0, j);
             const end = partial.slice(j);
-            const merged = start.concat(first, end);
+            const merged = [...start, first, ...end];
             output.push(merged);
         }
     }

package/lib/errors/index.js

@@ -1,5 +1,4 @@
 "use strict";
-// tslint:disable no-console
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.warn = exports.error = exports.exit = exports.config = exports.Logger = exports.CLIError = exports.ModuleLoadError = exports.ExitError = exports.handle = void 0;
 var handle_1 = require("./handle");

package/lib/errors/logger.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Logger = void 0;
+const fs = require("fs-extra");
 const path = require("path");
+const stripAnsi = require("strip-ansi");
 const timestamp = () => new Date().toISOString();
 let timer;
 const wait = (ms) => new Promise(resolve => {
@@ -15,18 +17,15 @@ function chomp(s) {
     return s;
 }
 class Logger {
-    // eslint-disable-next-line no-useless-constructor
     constructor(file) {
         this.file = file;
         this.flushing = Promise.resolve();
         this.buffer = [];
     }
     log(msg) {
-        const stripAnsi = require('strip-ansi');
         msg = stripAnsi(chomp(msg));
         const lines = msg.split('\n').map(l => `${timestamp()} ${l}`.trimEnd());
         this.buffer.push(...lines);
-        // tslint:disable-next-line no-console
         this.flush(50).catch(console.error);
     }
     async flush(waitForMs = 0) {
@@ -36,7 +35,6 @@ class Logger {
                 return;
             const mylines = this.buffer;
             this.buffer = [];
-            const fs = require('fs-extra');
             await fs.mkdirp(path.dirname(this.file));
             await fs.appendFile(this.file, mylines.join('\n') + '\n');
         });

package/lib/flags.d.ts

@@ -1,21 +1,49 @@
-import { OptionFlag, BooleanFlag, EnumFlagOptions, Default } from './interfaces';
-export { boolean, integer, url, directory, file, string, build, option, custom } from './parser';
-export declare function _enum<T = string>(opts: EnumFlagOptions<T, true> & {
+/// <reference types="node" />
+import { URL } from 'url';
+import { BooleanFlag } from './interfaces';
+import { FlagDefinition, OptionFlagDefaults, FlagParser } from './interfaces/parser';
+/**
+ * Create a custom flag.
+ *
+ * @example
+ * type Id = string
+ * type IdOpts = { startsWith: string; length: number };
+ *
+ * export const myFlag = custom<Id, IdOpts>({
+ *   parse: async (input, opts) => {
+ *     if (input.startsWith(opts.startsWith) && input.length === opts.length) {
+ *       return input
+ *     }
+ *
+ *     throw new Error('Invalid id')
+ *   },
+ * })
+ */
+export declare function custom<T, P = Record<string, unknown>>(defaults: {
+    parse: FlagParser<T, string, P>;
     multiple: true;
-} & ({
-    required: true;
-} | {
-    default: Default<T[]>;
-})): OptionFlag<T[]>;
-export declare function _enum<T = string>(opts: EnumFlagOptions<T, true> & {
-    multiple: true;
-}): OptionFlag<T[] | undefined>;
-export declare function _enum<T = string>(opts: EnumFlagOptions<T> & ({
-    required: true;
-} | {
-    default: Default<T>;
-})): OptionFlag<T>;
-export declare function _enum<T = string>(opts: EnumFlagOptions<T>): OptionFlag<T | undefined>;
-export { _enum as enum };
+} & Partial<OptionFlagDefaults<T, P, true>>): FlagDefinition<T, P>;
+export declare function custom<T, P = Record<string, unknown>>(defaults: {
+    parse: FlagParser<T, string, P>;
+} & Partial<OptionFlagDefaults<T, P>>): FlagDefinition<T, P>;
+export declare function custom<T = string, P = Record<string, unknown>>(defaults: Partial<OptionFlagDefaults<T, P>>): FlagDefinition<T, P>;
+export declare function boolean<T = boolean>(options?: Partial<BooleanFlag<T>>): BooleanFlag<T>;
+export declare const integer: FlagDefinition<number, {
+    min?: number | undefined;
+    max?: number | undefined;
+}>;
+export declare const directory: FlagDefinition<string, {
+    exists?: boolean | undefined;
+}>;
+export declare const file: FlagDefinition<string, {
+    exists?: boolean | undefined;
+}>;
+/**
+ * Initializes a string as a URL. Throws an error
+ * if the string is not a valid URL.
+ */
+export declare const url: FlagDefinition<URL, Record<string, unknown>>;
+declare const stringFlag: FlagDefinition<string, Record<string, unknown>>;
+export { stringFlag as string };
 export declare const version: (opts?: Partial<BooleanFlag<boolean>>) => BooleanFlag<void>;
 export declare const help: (opts?: Partial<BooleanFlag<boolean>>) => BooleanFlag<void>;