text: // flow-typed signature: f80a4e6d3b2974596a66aac0367591fc
  // flow-typed version: da30fe6876/yargs_v7.x.x/flow_>=v0.42.x
  
  declare module "yargs" {
    declare type Argv = {
      _: Array<string>,
      $0: string,
      [key: string]: mixed
    };
  
    declare type Options = $Shape<{
      alias: string | Array<string>,
      array: boolean,
      boolean: boolean,
      choices: Array<mixed>,
      coerce: (arg: mixed) => mixed,
      config: boolean,
      configParser: (configPath: string) => { [key: string]: mixed },
      conflicts: string | { [key: string]: string },
      count: boolean,
      default: mixed,
      defaultDescription: string,
      demandOption: boolean | string,
      desc: string,
      describe: string,
      description: string,
      global: boolean,
      group: string,
      implies: string | { [key: string]: string },
      nargs: number,
      normalize: boolean,
      number: boolean,
      requiresArg: boolean,
      skipValidation: boolean,
      string: boolean,
      type: "array" | "boolean" | "count" | "number" | "string"
    }>;
  
    declare type CommonModuleObject = {|
      command?: string | Array<string>,
      aliases?: Array<string> | string,
      builder?: { [key: string]: Options } | ((yargsInstance: Yargs) => mixed),
      handler?: (argv: Argv) => void
    |};
  
    declare type ModuleObjectDesc = {|
      ...CommonModuleObject,
      desc?: string | false
    |};
  
    declare type ModuleObjectDescribe = {|
      ...CommonModuleObject,
      describe?: string | false
    |};
  
    declare type ModuleObjectDescription = {|
      ...CommonModuleObject,
      description?: string | false
    |};
  
    declare type ModuleObject =
      | ModuleObjectDesc
      | ModuleObjectDescribe
      | ModuleObjectDescription;
  
    declare class Yargs {
      (args: Array<string>): Yargs;
  
      alias(key: string, alias: string): this;
      alias(alias: { [key: string]: string | Array<string> }): this;
      argv: Argv;
      array(key: string | Array<string>): this;
      boolean(paramter: string | Array<string>): this;
      check(fn: (argv: Argv, options: Array<string>) => ?boolean): this;
      choices(key: string, allowed: Array<string>): this;
      choices(allowed: { [key: string]: Array<string> }): this;
      coerce(key: string, fn: (value: any) => mixed): this;
      coerce(object: { [key: string]: (value: any) => mixed }): this;
      coerce(keys: Array<string>, fn: (value: any) => mixed): this;
  
      command(
        cmd: string | Array<string>,
        desc: string | false,
        builder?: { [key: string]: Options } | ((yargsInstance: Yargs) => mixed),
        handler?: Function
      ): this;
  
      command(
        cmd: string | Array<string>,
        desc: string | false,
        module: ModuleObject
      ): this;
  
      command(module: ModuleObject): this;
  
      completion(
        cmd: string,
        description?: string,
        fn?: (
          current: string,
          argv: Argv,
          done: (competion: Array<string>) => void
        ) => ?(Array<string> | Promise<Array<string>>)
      ): this;
  
      config(
        key?: string,
        description?: string,
        parseFn?: (configPath: string) => { [key: string]: mixed }
      ): this;
      config(
        key: string,
        parseFn?: (configPath: string) => { [key: string]: mixed }
      ): this;
      config(config: { [key: string]: mixed }): this;
  
      conflicts(keyA: string, keyB: string): this;
      conflicts(keys: { [key: string]: string }): this;
  
      count(name: string): this;
  
      default(key: string, value: mixed, description?: string): this;
      default(defaults: { [key: string]: mixed }): this;
  
      // Deprecated: use demandOption() and demandCommand() instead.
      demand(key: string, msg?: string | boolean): this;
      demand(count: number, max?: number, msg?: string | boolean): this;
  
      demandOption(key: string | Array<string>, msg?: string | boolean): this;
  
      demandCommand(min: number, minMsg?: string): this;
      demandCommand(
        min: number,
        max: number,
        minMsg?: string,
        maxMsg?: string
      ): this;
  
      describe(key: string, description: string): this;
      describe(describeObject: { [key: string]: string }): this;
  
      detectLocale(shouldDetect: boolean): this;
  
      env(prefix?: string): this;
  
      epilog(text: string): this;
      epilogue(text: string): this;
  
      example(cmd: string, desc: string): this;
  
      exitProcess(enable: boolean): this;
  
      fail(fn: (failureMessage: string, err: Error, yargs: Yargs) => mixed): this;
  
      getCompletion(args: Array<string>, fn: () => void): this;
  
      global(globals: string | Array<string>, isGlobal?: boolean): this;
  
      group(key: string | Array<string>, groupName: string): this;
  
      help(option?: string, desc?: string): this;
  
      implies(keyA: string, keyB: string): this;
      implies(keys: { [key: string]: string }): this;
  
      locale(
        locale:
          | "de"
          | "en"
          | "es"
          | "fr"
          | "hi"
          | "hu"
          | "id"
          | "it"
          | "ja"
          | "ko"
          | "nb"
          | "pirate"
          | "pl"
          | "pt"
          | "pt_BR"
          | "ru"
          | "th"
          | "tr"
          | "zh_CN"
      ): this;
      locale(): string;
  
      nargs(key: string, count: number): this;
  
      normalize(key: string): this;
  
      number(key: string | Array<string>): this;
  
      option(key: string, options?: Options): this;
      option(optionMap: { [key: string]: Options }): this;
  
      options(key: string, options?: Options): this;
      options(optionMap: { [key: string]: Options }): this;
  
      parse(
        args: string | Array<string>,
        context?: { [key: string]: mixed },
        parseCallback?: (err: Error, argv: Argv, output?: string) => void
      ): Argv;
      parse(
        args: string | Array<string>,
        parseCallback?: (err: Error, argv: Argv, output?: string) => void
      ): Argv;
  
      pkgConf(key: string, cwd?: string): this;
  
      recommendCommands(): this;
  
      // Alias of demand()
      require(key: string, msg: string | boolean): this;
      require(count: number, max?: number, msg?: string | boolean): this;
  
      requiresArg(key: string | Array<string>): this;
  
      reset(): this;
  
      showCompletionScript(): this;
  
      showHelp(consoleLevel?: "error" | "warn" | "log"): this;
  
      showHelpOnFail(enable: boolean, message?: string): this;
  
      strict(): this;
  
      skipValidation(key: string): this;
  
      strict(global?: boolean): this;
  
      string(key: string | Array<string>): this;
  
      updateLocale(obj: { [key: string]: string }): this;
      updateStrings(obj: { [key: string]: string }): this;
  
      usage(message: string, opts?: { [key: string]: Options }): this;
  
      version(): this;
      version(version: string): this;
      version(option: string | (() => string), version: string): this;
      version(
        option: string | (() => string),
        description: string | (() => string),
        version: string
      ): this;
  
      wrap(columns: number | null): this;
    }
  
    declare module.exports: Yargs;
  }
  