@types/optimist

property alias

alias?: string | string[] | undefined;

property default

default?: any;

property demand

demand?: string | number | string[] | undefined;

property describe

describe?: string | undefined;

property type

type?: string | undefined;

property argv

argv: any;

• Implicitly use process.argv array to construct the argv object

method alias

alias: {
    (key: string, alias: string | string[]): Parser;
    (aliases: { [index: string]: string | string[] }): Parser;
};

• Set key names as equivalent such that updates to a key will propagate to aliases and vice-versa.

• Take an object that maps keys to aliases.

method boolean

boolean: { (key: string): Parser; (key: string[]): 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.

• Interpret all the elements as booleans.

method check

check: (fn: (argv: any) => any) => 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.

method default

default: {
    (key: string, value: any): Parser;
    (defaults: { [index: string]: any }): Parser;
};

• Set argv[key] to value if no option was specified on process.argv

• Take an object that maps keys to default values

method demand

demand: {
    (key: string): Parser;
    (key: number): Parser;
    (key: string[]): Parser;
};

• Show the usage information and exit if key wasn't specified in process.argv

• Demand at least as many non-option arguments, which show up in argv._

• Demand each element in key

method describe

describe: {
    (key: string, desc: string): Parser;
    (descriptions: { [index: string]: string }): Parser;
};

• Describe a key for the generated usage information

• Take an object that maps keys to descriptions

method help

help: () => string;

• Return the generated usage string.

method options

options: {
    (key: string, opt: Opt): Parser;
    (options: { [index: string]: Opt }): Parser;
};

• Instead of chaining together, e.g. optimist.alias().demand().default()..., you can specify keys in opt for each of the chainable methods.

• Take an object that maps keys to opt parameters

method parse

parse: (args: string[]) => any;

• Use .parse() to do the same thing as treating optimist as a function

method showHelp

showHelp: (fn?: (message: string) => void) => void;

• Print the usage data using fn for printing (defaults to console.error).

method string

string: { (key: string): Parser; (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.

• Interpret all the elements as strings

method usage

usage: (message: string) => 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.

method wrap

wrap: (columns: number) => Parser;

• Format usage output to wrap at columns many columns.

call signature

(args: string[]): any;

• Pass in the process.argv yourself