From cf0ac34ebfb56af857def1c4952940fe8441abec Mon Sep 17 00:00:00 2001
From: Christopher Brown <io@henrian.com>
Date: Sun, 14 Feb 2016 18:18:08 -0600
Subject: [PATCH] Update 'optimist' declarations to match the optimist package
 documentation

---
 optimist/optimist.d.ts | 116 +++++++++++++++++++++++++++--------------
 1 file changed, 76 insertions(+), 40 deletions(-)

diff --git a/optimist/optimist.d.ts b/optimist/optimist.d.ts
index 06c89fcf5..7393190bd 100644
--- a/optimist/optimist.d.ts
+++ b/optimist/optimist.d.ts
@@ -1,53 +1,89 @@
 // Type definitions for optimist
 // Project: https://github.com/substack/node-optimist
-// Definitions by: Carlos Ballesteros Velasco <https://github.com/soywiz>
-// Definitions: https://github.com/borisyankov/DefinitelyTyped
-
-// Imported from: https://github.com/soywiz/typescript-node-definitions/optimist.d.ts
+// Definitions by: Carlos Ballesteros Velasco <https://github.com/soywiz>, Christopher Brown <https://github.com/chbrown>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 declare module "optimist" {
 
-	function optimist(args: string[]): optimist.Optimist;
-
 	module optimist {
-		export interface Optimist {
-			default(name: string, value: any): Optimist;
-			default(args: Object): Optimist;
-
-			boolean(name: string): Optimist;
-			boolean(names: string[]): Optimist;
-
-			string(name: string): Optimist;
-			string(names: string[]): Optimist;
-
-			wrap(columns: number): Optimist;
-
-			help(): void;
-			showHelp(fn?: Function): void;
-
-			usage(message: string): Optimist;
-
-			demand(key: string): Optimist;
-			demand(key: number): Optimist;
-			demand(key: string[]): Optimist;
-
-			alias(key: string, alias: string): Optimist;
-
-			describe(key: string, desc: string): Optimist;
-
-			options(key: string, opt: Object): Optimist;
-
-			check(fn: Function): void;
-
-			parse(args: string[]): Optimist;
-
-			argv: Argv;
+		interface Opt {
+			alias?: string | string[];
+			default?: any;
+			demand?: string | number | string[];
+			describe?: string;
+			type?: string;
 		}
 
-		export interface Argv extends Object {
-			_: 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): void;
+
+			/** 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;
 }