optimist.d.ts
3.56 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
// Type definitions for optimist
// Project: https://github.com/substack/node-optimist
// Definitions by: Carlos Ballesteros Velasco <https://github.com/soywiz>, Christopher Brown <https://github.com/chbrown>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
declare module "optimist" {
namespace optimist {
interface Opt {
alias?: string | string[];
default?: any;
demand?: string | number | string[];
describe?: string;
type?: string;
}
interface Parser {
/** Implicitly use process.argv array to construct the argv object */
argv: any;
/** Pass in the process.argv yourself */
(args: string[]): any;
/** Use .parse() to do the same thing as treating optimist as a function */
parse(args: string[]): any;
// The types below follow the order and documentation of https://github.com/substack/node-optimist
/** Set key names as equivalent such that updates to a key will propagate to aliases and vice-versa. */
alias(key: string, alias: string | string[]): Parser;
/** Take an object that maps keys to aliases. */
alias(aliases: {[index: string]: string | string[]}): Parser;
/** Set argv[key] to value if no option was specified on process.argv */
default(key: string, value: any): Parser;
/** Take an object that maps keys to default values */
default(defaults: {[index: string]: any}): Parser;
/** Show the usage information and exit if key wasn't specified in process.argv */
demand(key: string): Parser;
/** Demand at least as many non-option arguments, which show up in argv._ */
demand(key: number): Parser;
/** Demand each element in key */
demand(key: string[]): Parser;
/** Describe a key for the generated usage information */
describe(key: string, desc: string): Parser;
/** Take an object that maps keys to descriptions */
describe(descriptions: {[index: string]: string}): Parser;
/** Instead of chaining together, e.g. optimist.alias().demand().default()...,
you can specify keys in opt for each of the chainable methods. */
options(key: string, opt: Opt): Parser;
/** Take an object that maps keys to opt parameters */
options(options: {[index: string]: Opt}): Parser;
/** Set a usage message to show which commands to use. Inside message,
the string $0 will get interpolated to the current script name or node
command for the present script similar to how $0 works in bash or perl. */
usage(message: string): Parser;
/** Check that certain conditions are met in the provided arguments. If fn
throws or returns false, show the thrown error, usage information, and exit.
*/
check(fn: (argv: any) => any): Parser;
/** Interpret key as a boolean. If a non-flag option follows key in process.argv,
that string won't get set as the value of key. If key never shows up as a
flag in process.arguments, argv[key] will be false. */
boolean(key: string): Parser;
/** Interpret all the elements as booleans. */
boolean(key: string[]): Parser;
/** Tell the parser logic not to interpret key as a number or boolean. This can be useful if you need to preserve leading zeros in an input. */
string(key: string): Parser;
/** Interpret all the elements as strings */
string(key: string[]): Parser;
/** Format usage output to wrap at columns many columns. */
wrap(columns: number): Parser;
/** Return the generated usage string. */
help(): string;
/** Print the usage data using fn for printing (defaults to console.error). */
showHelp(fn?: (message: string) => void): void;
}
}
var optimist: optimist.Parser;
export = optimist;
}