1 |
|
2 |
|
3 |
|
4 |
|
5 |
|
6 |
|
7 |
|
8 | declare namespace commander {
|
9 |
|
10 | interface CommanderError extends Error {
|
11 | code: string;
|
12 | exitCode: number;
|
13 | message: string;
|
14 | nestedError?: string;
|
15 | }
|
16 | type CommanderErrorConstructor = new (exitCode: number, code: string, message: string) => CommanderError;
|
17 |
|
18 |
|
19 | interface InvalidOptionArgumentError extends CommanderError {
|
20 | }
|
21 | type InvalidOptionArgumentErrorConstructor = new (message: string) => InvalidOptionArgumentError;
|
22 |
|
23 | interface Option {
|
24 | flags: string;
|
25 | description: string;
|
26 |
|
27 | required: boolean;
|
28 | optional: boolean;
|
29 | variadic: boolean;
|
30 | mandatory: boolean;
|
31 | optionFlags: string;
|
32 | short?: string;
|
33 | long?: string;
|
34 | negate: boolean;
|
35 | defaultValue?: any;
|
36 | defaultValueDescription?: string;
|
37 | parseArg?: <T>(value: string, previous: T) => T;
|
38 | hidden: boolean;
|
39 | argChoices?: string[];
|
40 |
|
41 | |
42 |
|
43 |
|
44 | default(value: any, description?: string): this;
|
45 |
|
46 | |
47 |
|
48 |
|
49 | fullDescription(): string;
|
50 |
|
51 | |
52 |
|
53 |
|
54 | argParser<T>(fn: (value: string, previous: T) => T): this;
|
55 |
|
56 | /**
|
57 | * Whether the option is mandatory and must have a value after parsing.
|
58 | */
|
59 | makeOptionMandatory(mandatory?: boolean): this;
|
60 |
|
61 | /**
|
62 | * Hide option in help.
|
63 | */
|
64 | hideHelp(hide?: boolean): this;
|
65 |
|
66 | /**
|
67 | * Validation of option argument failed.
|
68 | * Intended for use from custom argument processing functions.
|
69 | */
|
70 | argumentRejected(messsage: string): never;
|
71 |
|
72 | /**
|
73 | * Only allow option value to be one of choices.
|
74 | */
|
75 | choices(values: string[]): this;
|
76 |
|
77 | /**
|
78 | * Return option name.
|
79 | */
|
80 | name(): string;
|
81 |
|
82 | /**
|
83 | * Return option name, in a camelcase format that can be used
|
84 | * as a object attribute key.
|
85 | */
|
86 | attributeName(): string;
|
87 | }
|
88 | type OptionConstructor = new (flags: string, description?: string) => Option;
|
89 |
|
90 | interface Help {
|
91 |
|
92 | helpWidth?: number;
|
93 | sortSubcommands: boolean;
|
94 | sortOptions: boolean;
|
95 |
|
96 |
|
97 | subcommandTerm(cmd: Command): string;
|
98 |
|
99 | subcommandDescription(cmd: Command): string;
|
100 |
|
101 | optionTerm(option: Option): string;
|
102 |
|
103 | optionDescription(option: Option): string;
|
104 |
|
105 |
|
106 | commandUsage(cmd: Command): string;
|
107 |
|
108 | commandDescription(cmd: Command): string;
|
109 |
|
110 |
|
111 | visibleCommands(cmd: Command): Command[];
|
112 |
|
113 | visibleOptions(cmd: Command): Option[];
|
114 |
|
115 | visibleArguments(cmd: Command): Array<{ term: string; description: string}>;
|
116 |
|
117 |
|
118 | longestSubcommandTermLength(cmd: Command, helper: Help): number;
|
119 |
|
120 | longestOptionTermLength(cmd: Command, helper: Help): number;
|
121 |
|
122 | longestArgumentTermLength(cmd: Command, helper: Help): number;
|
123 |
|
124 | padWidth(cmd: Command, helper: Help): number;
|
125 |
|
126 | |
127 |
|
128 |
|
129 |
|
130 | wrap(str: string, width: number, indent: number, minColumnWidth?: number): string;
|
131 |
|
132 |
|
133 | formatHelp(cmd: Command, helper: Help): string;
|
134 | }
|
135 | type HelpConstructor = new () => Help;
|
136 | type HelpConfiguration = Partial<Help>;
|
137 |
|
138 | interface ParseOptions {
|
139 | from: 'node' | 'electron' | 'user';
|
140 | }
|
141 | interface HelpContext {
|
142 | error: boolean;
|
143 | }
|
144 | interface AddHelpTextContext {
|
145 | error: boolean;
|
146 | command: Command;
|
147 | }
|
148 | interface OutputConfiguration {
|
149 | writeOut?(str: string): void;
|
150 | writeErr?(str: string): void;
|
151 | getOutHelpWidth?(): number;
|
152 | getErrHelpWidth?(): number;
|
153 | outputError?(str: string, write: (str: string) => void): void;
|
154 |
|
155 | }
|
156 |
|
157 | type AddHelpTextPosition = 'beforeAll' | 'before' | 'after' | 'afterAll';
|
158 |
|
159 | interface OptionValues {
|
160 | [key: string]: any;
|
161 | }
|
162 |
|
163 | interface Command {
|
164 | args: string[];
|
165 | commands: Command[];
|
166 | parent: Command | null;
|
167 |
|
168 | /**
|
169 | * Set the program version to `str`.
|
170 | *
|
171 | * This method auto-registers the "-V, --version" flag
|
172 | * which will print the version number when passed.
|
173 | *
|
174 | * You can optionally supply the flags and description to override the defaults.
|
175 | */
|
176 | version(str: string, flags?: string, description?: string): this;
|
177 |
|
178 | /**
|
179 | * Define a command, implemented using an action handler.
|
180 | *
|
181 | * @remarks
|
182 | * The command description is supplied using `.description`, not as a parameter to `.command`.
|
183 | *
|
184 | * @example
|
185 | * ```ts
|
186 | * program
|
187 | * .command('clone <source> [destination]')
|
188 | * .description('clone a repository into a newly created directory')
|
189 | * .action((source, destination) => {
|
190 | * console.log('clone command called');
|
191 | * });
|
192 | * ```
|
193 | *
|
194 | * @param nameAndArgs - command name and arguments, args are `<required>` or `[optional]` and last may also be `variadic...`
|
195 | * @param opts - configuration options
|
196 | * @returns new command
|
197 | */
|
198 | command(nameAndArgs: string, opts?: CommandOptions): ReturnType<this['createCommand']>;
|
199 | /**
|
200 | * Define a command, implemented in a separate executable file.
|
201 | *
|
202 | * @remarks
|
203 | * The command description is supplied as the second parameter to `.command`.
|
204 | *
|
205 | * @example
|
206 | * ```ts
|
207 | * program
|
208 | * .command('start <service>', 'start named service')
|
209 | * .command('stop [service]', 'stop named service, or all if no name supplied');
|
210 | * ```
|
211 | *
|
212 | * @param nameAndArgs - command name and arguments, args are `<required>` or `[optional]` and last may also be `variadic...`
|
213 | * @param description - description of executable command
|
214 | * @param opts - configuration options
|
215 | * @returns `this` command for chaining
|
216 | */
|
217 | command(nameAndArgs: string, description: string, opts?: commander.ExecutableCommandOptions): this;
|
218 |
|
219 | /**
|
220 | * Factory routine to create a new unattached command.
|
221 | *
|
222 | * See .command() for creating an attached subcommand, which uses this routine to
|
223 | * create the command. You can override createCommand to customise subcommands.
|
224 | */
|
225 | createCommand(name?: string): Command;
|
226 |
|
227 | /**
|
228 | * Add a prepared subcommand.
|
229 | *
|
230 | * See .command() for creating an attached subcommand which inherits settings from its parent.
|
231 | *
|
232 | * @returns `this` command for chaining
|
233 | */
|
234 | addCommand(cmd: Command, opts?: CommandOptions): this;
|
235 |
|
236 | /**
|
237 | * Define argument syntax for command.
|
238 | *
|
239 | * @returns `this` command for chaining
|
240 | */
|
241 | arguments(desc: string): this;
|
242 |
|
243 | /**
|
244 | * Override default decision whether to add implicit help command.
|
245 | *
|
246 | * addHelpCommand() // force on
|
247 | * addHelpCommand(false); // force off
|
248 | * addHelpCommand('help [cmd]', 'display help for [cmd]'); // force on with custom details
|
249 | *
|
250 | * @returns `this` command for chaining
|
251 | */
|
252 | addHelpCommand(enableOrNameAndArgs?: string | boolean, description?: string): this;
|
253 |
|
254 | /**
|
255 | * Register callback to use as replacement for calling process.exit.
|
256 | */
|
257 | exitOverride(callback?: (err: CommanderError) => never|void): this;
|
258 |
|
259 | /**
|
260 | * You can customise the help with a subclass of Help by overriding createHelp,
|
261 | * or by overriding Help properties using configureHelp().
|
262 | */
|
263 | createHelp(): Help;
|
264 |
|
265 | /**
|
266 | * You can customise the help by overriding Help properties using configureHelp(),
|
267 | * or with a subclass of Help by overriding createHelp().
|
268 | */
|
269 | configureHelp(configuration: HelpConfiguration): this;
|
270 | /** Get configuration */
|
271 | configureHelp(): HelpConfiguration;
|
272 |
|
273 | /**
|
274 | * The default output goes to stdout and stderr. You can customise this for special
|
275 | * applications. You can also customise the display of errors by overriding outputError.
|
276 | *
|
277 | * The configuration properties are all functions:
|
278 | *
|
279 | * // functions to change where being written, stdout and stderr
|
280 | * writeOut(str)
|
281 | * writeErr(str)
|
282 | * // matching functions to specify width for wrapping help
|
283 | * getOutHelpWidth()
|
284 | * getErrHelpWidth()
|
285 | * // functions based on what is being written out
|
286 | * outputError(str, write) // used for displaying errors, and not used for displaying help
|
287 | */
|
288 | configureOutput(configuration: OutputConfiguration): this;
|
289 | /** Get configuration */
|
290 | configureOutput(): OutputConfiguration;
|
291 |
|
292 | /**
|
293 | * Register callback `fn` for the command.
|
294 | *
|
295 | * @example
|
296 | * program
|
297 | * .command('help')
|
298 | * .description('display verbose help')
|
299 | * .action(function() {
|
300 | *
|
301 | * });
|
302 | *
|
303 | * @returns `this` command for chaining
|
304 | */
|
305 | action(fn: (...args: any[]) => void | Promise<void>): this;
|
306 |
|
307 | /**
|
308 | * Define option with `flags`, `description` and optional
|
309 | * coercion `fn`.
|
310 | *
|
311 | * The `flags` string contains the short and/or long flags,
|
312 | * separated by comma, a pipe or space. The following are all valid
|
313 | * all will output this way when `--help` is used.
|
314 | *
|
315 | * "-p, --pepper"
|
316 | * "-p|--pepper"
|
317 | * "-p --pepper"
|
318 | *
|
319 | * @example
|
320 | * // simple boolean defaulting to false
|
321 | * program.option('-p, --pepper', 'add pepper');
|
322 | *
|
323 | * --pepper
|
324 | * program.pepper
|
325 | * // => Boolean
|
326 | *
|
327 | *
|
328 | * program.option('-C, --no-cheese', 'remove cheese');
|
329 | *
|
330 | * program.cheese
|
331 | *
|
332 | *
|
333 | * --no-cheese
|
334 | * program.cheese
|
335 | *
|
336 | *
|
337 | *
|
338 | * program.option('-C, --chdir <path>', 'change the working directory');
|
339 | *
|
340 | * --chdir /tmp
|
341 | * program.chdir
|
342 | *
|
343 | *
|
344 | *
|
345 | * program.option('-c, --cheese [type]', 'add cheese [marble]');
|
346 | *
|
347 | * @returns `this` command for chaining
|
348 | */
|
349 | option(flags: string, description?: string, defaultValue?: string | boolean): this;
|
350 | option<T>(flags: string, description: string, fn: (value: string, previous: T) => T, defaultValue?: T): this;
|
351 | /** @deprecated since v7, instead use choices or a custom function */
|
352 | option(flags: string, description: string, regexp: RegExp, defaultValue?: string | boolean): this;
|
353 |
|
354 | /**
|
355 | * Define a required option, which must have a value after parsing. This usually means
|
356 | * the option must be specified on the command line. (Otherwise the same as .option().)
|
357 | *
|
358 | * The `flags` string contains the short and/or long flags, separated by comma, a pipe or space.
|
359 | */
|
360 | requiredOption(flags: string, description?: string, defaultValue?: string | boolean): this;
|
361 | requiredOption<T>(flags: string, description: string, fn: (value: string, previous: T) => T, defaultValue?: T): this;
|
362 | /** @deprecated since v7, instead use choices or a custom function */
|
363 | requiredOption(flags: string, description: string, regexp: RegExp, defaultValue?: string | boolean): this;
|
364 |
|
365 | /**
|
366 | * Factory routine to create a new unattached option.
|
367 | *
|
368 | * See .option() for creating an attached option, which uses this routine to
|
369 | * create the option. You can override createOption to return a custom option.
|
370 | */
|
371 |
|
372 | createOption(flags: string, description?: string): Option;
|
373 |
|
374 | /**
|
375 | * Add a prepared Option.
|
376 | *
|
377 | * See .option() and .requiredOption() for creating and attaching an option in a single call.
|
378 | */
|
379 | addOption(option: Option): this;
|
380 |
|
381 | /**
|
382 | * Whether to store option values as properties on command object,
|
383 | * or store separately (specify false). In both cases the option values can be accessed using .opts().
|
384 | *
|
385 | * @returns `this` command for chaining
|
386 | */
|
387 | storeOptionsAsProperties(): this & OptionValues;
|
388 | storeOptionsAsProperties(storeAsProperties: true): this & OptionValues;
|
389 | storeOptionsAsProperties(storeAsProperties?: boolean): this;
|
390 |
|
391 | /**
|
392 | * Alter parsing of short flags with optional values.
|
393 | *
|
394 | * @example
|
395 | * // for `.option('-f,--flag [value]'):
|
396 | * .combineFlagAndOptionalValue(true) // `-f80` is treated like `--flag=80`, this is the default behaviour
|
397 | * .combineFlagAndOptionalValue(false) // `-fb` is treated like `-f -b`
|
398 | *
|
399 | * @returns `this` command for chaining
|
400 | */
|
401 | combineFlagAndOptionalValue(combine?: boolean): this;
|
402 |
|
403 | /**
|
404 | * Allow unknown options on the command line.
|
405 | *
|
406 | * @returns `this` command for chaining
|
407 | */
|
408 | allowUnknownOption(allowUnknown?: boolean): this;
|
409 |
|
410 | /**
|
411 | * Allow excess command-arguments on the command line. Pass false to make excess arguments an error.
|
412 | *
|
413 | * @returns `this` command for chaining
|
414 | */
|
415 | allowExcessArguments(allowExcess?: boolean): this;
|
416 |
|
417 | /**
|
418 | * Enable positional options. Positional means global options are specified before subcommands which lets
|
419 | * subcommands reuse the same option names, and also enables subcommands to turn on passThroughOptions.
|
420 | *
|
421 | * The default behaviour is non-positional and global options may appear anywhere on the command line.
|
422 | *
|
423 | * @returns `this` command for chaining
|
424 | */
|
425 | enablePositionalOptions(positional?: boolean): this;
|
426 |
|
427 | /**
|
428 | * Pass through options that come after command-arguments rather than treat them as command-options,
|
429 | * so actual command-options come before command-arguments. Turning this on for a subcommand requires
|
430 | * positional options to have been enabled on the program (parent commands).
|
431 | *
|
432 | * The default behaviour is non-positional and options may appear before or after command-arguments.
|
433 | *
|
434 | * @returns `this` command for chaining
|
435 | */
|
436 | passThroughOptions(passThrough?: boolean): this;
|
437 |
|
438 | /**
|
439 | * Parse `argv`, setting options and invoking commands when defined.
|
440 | *
|
441 | * The default expectation is that the arguments are from node and have the application as argv[0]
|
442 | * and the script being run in argv[1], with user parameters after that.
|
443 | *
|
444 | * Examples:
|
445 | *
|
446 | * program.parse(process.argv);
|
447 | * program.parse(); // implicitly use process.argv and auto-detect node vs electron conventions
|
448 | * program.parse(my-args, { from: 'user' }); // just user supplied arguments, nothing special about argv[0]
|
449 | *
|
450 | * @returns `this` command for chaining
|
451 | */
|
452 | parse(argv?: string[], options?: ParseOptions): this;
|
453 |
|
454 | /**
|
455 | * Parse `argv`, setting options and invoking commands when defined.
|
456 | *
|
457 | * Use parseAsync instead of parse if any of your action handlers are async. Returns a Promise.
|
458 | *
|
459 | * The default expectation is that the arguments are from node and have the application as argv[0]
|
460 | * and the script being run in argv[1], with user parameters after that.
|
461 | *
|
462 | * Examples:
|
463 | *
|
464 | * program.parseAsync(process.argv);
|
465 | * program.parseAsync(); // implicitly use process.argv and auto-detect node vs electron conventions
|
466 | * program.parseAsync(my-args, { from: 'user' }); // just user supplied arguments, nothing special about argv[0]
|
467 | *
|
468 | * @returns Promise
|
469 | */
|
470 | parseAsync(argv?: string[], options?: ParseOptions): Promise<this>;
|
471 |
|
472 | /**
|
473 | * Parse options from `argv` removing known options,
|
474 | * and return argv split into operands and unknown arguments.
|
475 | *
|
476 | * @example
|
477 | * argv => operands, unknown
|
478 | * --known kkk op => [op], []
|
479 | * op --known kkk => [op], []
|
480 | * sub --unknown uuu op => [sub], [--unknown uuu op]
|
481 | * sub -- --unknown uuu op => [sub --unknown uuu op], []
|
482 | */
|
483 | parseOptions(argv: string[]): commander.ParseOptionsResult;
|
484 |
|
485 | |
486 |
|
487 |
|
488 | opts(): OptionValues;
|
489 |
|
490 | |
491 |
|
492 |
|
493 |
|
494 |
|
495 | description(str: string, argsDescription?: {[argName: string]: string}): this;
|
496 | |
497 |
|
498 |
|
499 | description(): string;
|
500 |
|
501 | |
502 |
|
503 |
|
504 |
|
505 |
|
506 |
|
507 |
|
508 | alias(alias: string): this;
|
509 | |
510 |
|
511 |
|
512 | alias(): string;
|
513 |
|
514 | |
515 |
|
516 |
|
517 |
|
518 |
|
519 |
|
520 |
|
521 | aliases(aliases: string[]): this;
|
522 | |
523 |
|
524 |
|
525 | aliases(): string[];
|
526 |
|
527 | |
528 |
|
529 |
|
530 |
|
531 |
|
532 | usage(str: string): this;
|
533 | |
534 |
|
535 |
|
536 | usage(): string;
|
537 |
|
538 | |
539 |
|
540 |
|
541 |
|
542 |
|
543 | name(str: string): this;
|
544 | |
545 |
|
546 |
|
547 | name(): string;
|
548 |
|
549 | |
550 |
|
551 |
|
552 |
|
553 |
|
554 |
|
555 | outputHelp(context?: HelpContext): void;
|
556 |
|
557 | outputHelp(cb?: (str: string) => string): void;
|
558 |
|
559 | |
560 |
|
561 |
|
562 | helpInformation(context?: HelpContext): string;
|
563 |
|
564 | |
565 |
|
566 |
|
567 |
|
568 |
|
569 | helpOption(flags?: string | boolean, description?: string): this;
|
570 |
|
571 | |
572 |
|
573 |
|
574 |
|
575 |
|
576 | help(context?: HelpContext): never;
|
577 |
|
578 | help(cb?: (str: string) => string): never;
|
579 |
|
580 | |
581 |
|
582 |
|
583 |
|
584 |
|
585 |
|
586 | addHelpText(position: AddHelpTextPosition, text: string): this;
|
587 | addHelpText(position: AddHelpTextPosition, text: (context: AddHelpTextContext) => string | undefined): this;
|
588 |
|
589 | |
590 |
|
591 |
|
592 | on(event: string | symbol, listener: (...args: any[]) => void): this;
|
593 | }
|
594 | type CommandConstructor = new (name?: string) => Command;
|
595 |
|
596 | interface CommandOptions {
|
597 | hidden?: boolean;
|
598 | isDefault?: boolean;
|
599 |
|
600 | noHelp?: boolean;
|
601 | }
|
602 | interface ExecutableCommandOptions extends CommandOptions {
|
603 | executableFile?: string;
|
604 | }
|
605 |
|
606 |
|
607 | interface ParseOptionsResult {
|
608 | operands: string[];
|
609 | unknown: string[];
|
610 | }
|
611 |
|
612 |
|
613 | interface CommanderStatic extends Command {
|
614 | program: Command;
|
615 | Command: CommandConstructor;
|
616 | Option: OptionConstructor;
|
617 | CommanderError: CommanderErrorConstructor;
|
618 | InvalidOptionArgumentError: InvalidOptionArgumentErrorConstructor;
|
619 | Help: HelpConstructor;
|
620 | }
|
621 |
|
622 | }
|
623 |
|
624 |
|
625 |
|
626 | declare const commander: commander.CommanderStatic;
|
627 | export = commander;
|